From fdd47c68d049ccaf64a2edb820905c65470f3b5d Mon Sep 17 00:00:00 2001 From: benk10 Date: Tue, 6 Oct 2026 22:14:25 -0500 Subject: [PATCH 01/62] feat: add usdt wallet and paykit payments --- app/build.gradle.kts | 16 +- .../ui/components/UsdtReceivePrivacyTest.kt | 54 ++ .../ui/onboarding/MnemonicInputFieldTest.kt | 1 + .../CreatePaymentRequestScreenTest.kt | 16 +- .../PaymentRequestsScreenTest.kt | 12 +- .../CreateSubscriptionScreenTest.kt | 23 +- .../wallets/send/SendConfirmScreenTest.kt | 8 +- .../main/java/to/bitkit/data/SettingsStore.kt | 1 + .../java/to/bitkit/data/keychain/Keychain.kt | 1 + app/src/main/java/to/bitkit/env/Env.kt | 18 + .../java/to/bitkit/models/BackupPayloads.kt | 1 + .../models/NewTransactionSheetDetails.kt | 1 + .../java/to/bitkit/models/PaykitAmount.kt | 91 +++ .../bitkit/models/PaykitPaymentStateBackup.kt | 4 + .../to/bitkit/models/PaykitRequestPricing.kt | 136 ++++ .../main/java/to/bitkit/models/PaykitUsdt.kt | 54 ++ .../to/bitkit/models/PaykitUsdtStateBackup.kt | 38 ++ .../to/bitkit/models/PubkyAuthClaimCodec.kt | 4 + .../java/to/bitkit/models/PubkyAuthRequest.kt | 45 +- .../java/to/bitkit/repositories/BackupRepo.kt | 45 +- .../ContactPaymentSettingsRepo.kt | 3 + .../to/bitkit/repositories/CurrencyRepo.kt | 5 + .../repositories/PaykitPaymentProofRepo.kt | 69 +- .../repositories/PaykitPaymentRequestRepo.kt | 181 ++++-- .../bitkit/repositories/PaykitSubscription.kt | 61 +- ...PaykitSubscriptionNotificationScheduler.kt | 1 - .../PaykitSubscriptionProposal.kt | 48 +- .../repositories/PaykitUsdtPaymentRepo.kt | 589 +++++++++++++++++ .../bitkit/repositories/PrivatePaykitRepo.kt | 5 + .../bitkit/repositories/PublicPaykitRepo.kt | 20 +- .../to/bitkit/repositories/UsdtDepositRepo.kt | 17 + .../java/to/bitkit/repositories/UsdtRepo.kt | 209 ++++++ .../to/bitkit/services/PaykitSdkService.kt | 16 +- .../java/to/bitkit/services/UsdtService.kt | 131 ++++ app/src/main/java/to/bitkit/ui/ContentView.kt | 23 +- .../main/java/to/bitkit/ui/MainActivity.kt | 2 + .../java/to/bitkit/ui/components/Money.kt | 3 +- .../ui/components/NumberPadActionButton.kt | 10 +- .../ui/components/NumberPadTextField.kt | 113 ++-- .../bitkit/ui/components/PaykitAmountView.kt | 43 ++ .../ui/components/PaymentAddressInput.kt | 30 + .../components/PaymentReviewIllustration.kt | 30 + .../bitkit/ui/components/UsdtAmountHeader.kt | 30 + .../bitkit/ui/components/WalletBalanceView.kt | 116 ++-- .../ui/screens/contacts/AddContactScreen.kt | 5 +- .../screens/contacts/AddContactViewModel.kt | 11 +- .../screens/contacts/ContactDetailScreen.kt | 5 +- .../contacts/ContactDetailViewModel.kt | 3 + .../CreatePaymentRequestScreen.kt | 215 +++++-- .../IncomingPaymentRequestDetailsScreen.kt | 41 +- .../paymentrequests/PaymentRequestsScreen.kt | 45 +- .../screens/profile/PubkyAuthApprovalSheet.kt | 117 +++- .../profile/PubkyAuthApprovalViewModel.kt | 60 +- .../screens/scanner/CameraPermissionView.kt | 24 +- .../subscriptions/CreateSubscriptionScreen.kt | 62 +- .../screens/subscriptions/SubscriptionRow.kt | 4 +- .../subscriptions/SubscriptionsScreen.kt | 76 ++- .../ui/screens/trezor/TrezorPreviewData.kt | 3 + .../bitkit/ui/screens/wallets/HomeScreen.kt | 8 + .../ui/screens/wallets/HomeViewModel.kt | 11 +- .../components/ActivityListGrouped.kt | 14 + .../activity/components/ActivityRow.kt | 27 +- .../wallets/receive/ReceiveQrScreen.kt | 141 ++-- .../screens/wallets/receive/ReceiveSheet.kt | 8 +- .../screens/wallets/send/SendAddressScreen.kt | 29 +- .../screens/wallets/send/SendAmountScreen.kt | 128 +++- .../screens/wallets/send/SendConfirmScreen.kt | 42 +- .../wallets/send/SendContactSelectScreen.kt | 5 +- .../send/SendContactSelectViewModel.kt | 3 + .../screens/wallets/send/SendPendingScreen.kt | 2 +- .../screens/wallets/usdt/PaykitUsdtReview.kt | 137 ++++ .../wallets/usdt/UsdtActivityDetail.kt | 266 ++++++++ .../wallets/usdt/UsdtDepositReceiveScreen.kt | 526 +++++++++++++++ .../wallets/usdt/UsdtDepositViewModel.kt | 159 +++++ .../wallets/usdt/UsdtReceiveContent.kt | 106 +++ .../screens/wallets/usdt/UsdtSendContent.kt | 543 ++++++++++++++++ .../ui/screens/wallets/usdt/UsdtViewModel.kt | 249 ++++++++ .../screens/wallets/usdt/UsdtWalletScreen.kt | 425 ++++++++++++ .../bitkit/ui/sheets/NewTransactionSheet.kt | 62 +- .../java/to/bitkit/ui/sheets/SendSheet.kt | 25 +- .../bitkit/ui/utils/NumberPadInputHandler.kt | 57 ++ .../bitkit/ui/utils/PubkyAuthErrorMessage.kt | 1 + .../to/bitkit/usecases/WipeWalletUseCase.kt | 3 +- .../bitkit/viewmodels/AmountInputViewModel.kt | 60 +- .../java/to/bitkit/viewmodels/AppViewModel.kt | 442 +++++++++++-- app/src/main/res/values/strings.xml | 108 ++++ .../java/to/bitkit/models/PaykitAmountTest.kt | 53 ++ .../models/PaykitPaymentStateBackupTest.kt | 84 +++ .../bitkit/models/PaykitRequestPricingTest.kt | 123 ++++ .../to/bitkit/repositories/BackupRepoTest.kt | 67 ++ .../PaykitPaymentProofRepoTest.kt | 110 ++-- ...aykitPaymentRequestRepoSubscriptionTest.kt | 147 ++++- .../PaykitPaymentRequestRepoTest.kt | 210 +++--- ...itSubscriptionNotificationSchedulerTest.kt | 22 +- .../PaykitSubscriptionProposalTest.kt | 1 + .../repositories/PaykitSubscriptionTest.kt | 8 +- .../repositories/PaykitUsdtPaymentRepoTest.kt | 603 ++++++++++++++++++ .../repositories/PrivatePaykitRepoTest.kt | 115 +++- .../repositories/PublicPaykitRepoTest.kt | 38 +- .../to/bitkit/repositories/TrezorRepoTest.kt | 3 + .../to/bitkit/repositories/UsdtRepoTest.kt | 234 +++++++ .../PaymentRequestPresentationTest.kt | 4 +- .../profile/PubkyAuthApprovalRetryTest.kt | 2 +- .../profile/PubkyAuthApprovalViewModelTest.kt | 144 ++++- .../subscriptions/SubscriptionsScreenTest.kt | 22 +- .../ui/screens/wallets/HomeViewModelTest.kt | 19 + .../wallets/usdt/UsdtDepositViewModelTest.kt | 143 +++++ .../screens/wallets/usdt/UsdtViewModelTest.kt | 220 +++++++ .../bitkit/usecases/WipeWalletUseCaseTest.kt | 9 + .../viewmodels/AppViewModelSendFlowTest.kt | 406 +++++++++--- changelog.d/next/usdt.added.md | 1 + docs/earn-receiving-details.md | 39 ++ docs/screens-map.md | 7 + docs/usdt-qa.md | 74 +++ docs/usdt.md | 43 ++ gradle/libs.versions.toml | 2 +- journeys/paykit-quoted-usdt.xml | 11 + .../pubky-auth/share-receiving-details.xml | 13 + journeys/subscriptions/create-and-propose.xml | 2 +- journeys/usdt-wallet-navigation.xml | 10 + settings.gradle.kts | 5 +- 121 files changed, 8624 insertions(+), 952 deletions(-) create mode 100644 app/src/androidTest/java/to/bitkit/ui/components/UsdtReceivePrivacyTest.kt create mode 100644 app/src/main/java/to/bitkit/models/PaykitAmount.kt create mode 100644 app/src/main/java/to/bitkit/models/PaykitRequestPricing.kt create mode 100644 app/src/main/java/to/bitkit/models/PaykitUsdt.kt create mode 100644 app/src/main/java/to/bitkit/models/PaykitUsdtStateBackup.kt create mode 100644 app/src/main/java/to/bitkit/repositories/PaykitUsdtPaymentRepo.kt create mode 100644 app/src/main/java/to/bitkit/repositories/UsdtDepositRepo.kt create mode 100644 app/src/main/java/to/bitkit/repositories/UsdtRepo.kt create mode 100644 app/src/main/java/to/bitkit/services/UsdtService.kt create mode 100644 app/src/main/java/to/bitkit/ui/components/PaykitAmountView.kt create mode 100644 app/src/main/java/to/bitkit/ui/components/PaymentAddressInput.kt create mode 100644 app/src/main/java/to/bitkit/ui/components/PaymentReviewIllustration.kt create mode 100644 app/src/main/java/to/bitkit/ui/components/UsdtAmountHeader.kt create mode 100644 app/src/main/java/to/bitkit/ui/screens/wallets/usdt/PaykitUsdtReview.kt create mode 100644 app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtActivityDetail.kt create mode 100644 app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtDepositReceiveScreen.kt create mode 100644 app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtDepositViewModel.kt create mode 100644 app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtReceiveContent.kt create mode 100644 app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtSendContent.kt create mode 100644 app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtViewModel.kt create mode 100644 app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtWalletScreen.kt create mode 100644 app/src/main/java/to/bitkit/ui/utils/NumberPadInputHandler.kt create mode 100644 app/src/test/java/to/bitkit/models/PaykitAmountTest.kt create mode 100644 app/src/test/java/to/bitkit/models/PaykitRequestPricingTest.kt create mode 100644 app/src/test/java/to/bitkit/repositories/PaykitUsdtPaymentRepoTest.kt create mode 100644 app/src/test/java/to/bitkit/repositories/UsdtRepoTest.kt create mode 100644 app/src/test/java/to/bitkit/ui/screens/wallets/usdt/UsdtDepositViewModelTest.kt create mode 100644 app/src/test/java/to/bitkit/ui/screens/wallets/usdt/UsdtViewModelTest.kt create mode 100644 changelog.d/next/usdt.added.md create mode 100644 docs/earn-receiving-details.md create mode 100644 docs/usdt-qa.md create mode 100644 docs/usdt.md create mode 100644 journeys/paykit-quoted-usdt.xml create mode 100644 journeys/pubky-auth/share-receiving-details.xml create mode 100644 journeys/usdt-wallet-navigation.xml diff --git a/app/build.gradle.kts b/app/build.gradle.kts index 955d5e477d..55087c089e 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -320,6 +320,11 @@ androidComponents { val buildConfigFields = requireNotNull(variant.buildConfigFields) { "buildFeatures.buildConfig must stay enabled for '${variant.name}'." } + buildConfigFields.put("USDT_BUNDLER_URL", localProp("USDT_BUNDLER_URL").orElse("").stringField()) + buildConfigFields.put("USDT_BRIDGES_URL", localProp("USDT_BRIDGES_URL").orElse("").stringField()) + buildConfigFields.put("USDT_DEPOSITS_URL", localProp("USDT_DEPOSITS_URL").orElse("").stringField()) + buildConfigFields.put("USDT_BRIDGE_NETWORKS", localProp("USDT_BRIDGE_NETWORKS").orElse("").stringField()) + buildConfigFields.put("USDT_RPC_URL", localProp("USDT_RPC_URL").orElse("").stringField()) buildConfigFields.put("E2E", e2eEnv.booleanField()) buildConfigFields.put("E2E_BACKEND", e2eBackendEnv.stringField()) buildConfigFields.put("E2E_LOCAL_HOST", e2eLocalHostEnv.stringField()) @@ -516,10 +521,17 @@ dependencies { // Crypto implementation(libs.bouncycastle.provider.jdk) implementation(libs.ldk.node.android) { exclude(group = "net.java.dev.jna", module = "jna") } - implementation(libs.bitkit.core) + val localBitkitCoreAar = providers.gradleProperty("bitkitCoreAar").orNull + if (localBitkitCoreAar != null) { + debugImplementation(files(localBitkitCoreAar)) + debugImplementation("org.jetbrains.kotlinx:atomicfu:0.23.1") + releaseImplementation(libs.bitkit.core) + } else { + implementation(libs.bitkit.core) + } implementation(libs.paykit) implementation(libs.vss.client) - nativeDebugSymbols(libs.bitkit.core.nativeDebugSymbolsArtifact()) + if (localBitkitCoreAar == null) nativeDebugSymbols(libs.bitkit.core.nativeDebugSymbolsArtifact()) nativeDebugSymbols(libs.ldk.node.android.nativeDebugSymbolsArtifact()) nativeDebugSymbols(libs.paykit.nativeDebugSymbolsArtifact()) nativeDebugSymbols(libs.vss.client.nativeDebugSymbolsArtifact()) diff --git a/app/src/androidTest/java/to/bitkit/ui/components/UsdtReceivePrivacyTest.kt b/app/src/androidTest/java/to/bitkit/ui/components/UsdtReceivePrivacyTest.kt new file mode 100644 index 0000000000..57cc366217 --- /dev/null +++ b/app/src/androidTest/java/to/bitkit/ui/components/UsdtReceivePrivacyTest.kt @@ -0,0 +1,54 @@ +package to.bitkit.ui.components + +import androidx.compose.runtime.mutableStateOf +import androidx.compose.ui.test.assertIsDisplayed +import androidx.compose.ui.test.junit4.v2.createComposeRule +import androidx.compose.ui.test.onNodeWithText +import dagger.hilt.android.testing.HiltAndroidRule +import dagger.hilt.android.testing.HiltAndroidTest +import org.junit.Before +import org.junit.Rule +import org.junit.Test +import to.bitkit.models.NewTransactionSheetDetails +import to.bitkit.models.NewTransactionSheetDirection +import to.bitkit.models.NewTransactionSheetType +import to.bitkit.test.annotations.ComposeUi +import to.bitkit.ui.sheets.NewTransactionSheetView +import to.bitkit.ui.theme.AppThemeSurface + +@HiltAndroidTest +@ComposeUi +class UsdtReceivePrivacyTest { + @get:Rule + val hiltRule = HiltAndroidRule(this) + + @get:Rule + val composeTestRule = createComposeRule() + + @Before + fun setup() { + hiltRule.inject() + } + + @Test + fun incomingPaymentHonorsHiddenBalance() { + val hidden = mutableStateOf(true) + composeTestRule.setContent { + AppThemeSurface { + NewTransactionSheetView( + details = NewTransactionSheetDetails( + type = NewTransactionSheetType.ONCHAIN, + direction = NewTransactionSheetDirection.RECEIVED, + usdtAmount = 123_456_789uL, + ), + onCloseClick = {}, + onDetailClick = {}, + hideBalance = hidden.value, + ) + } + } + composeTestRule.onNodeWithText("123.456789").assertDoesNotExist() + composeTestRule.runOnIdle { hidden.value = false } + composeTestRule.onNodeWithText("123.456789").assertIsDisplayed() + } +} diff --git a/app/src/androidTest/java/to/bitkit/ui/onboarding/MnemonicInputFieldTest.kt b/app/src/androidTest/java/to/bitkit/ui/onboarding/MnemonicInputFieldTest.kt index 079a727c1e..ec977b550a 100644 --- a/app/src/androidTest/java/to/bitkit/ui/onboarding/MnemonicInputFieldTest.kt +++ b/app/src/androidTest/java/to/bitkit/ui/onboarding/MnemonicInputFieldTest.kt @@ -61,6 +61,7 @@ class MnemonicInputFieldTest { onPositionChange = {}, onBackspaceInEmpty = { backspaceInEmptyCount++ }, focusRequester = focusRequester, + isFocused = true, index = 0, isFocused = true, ) diff --git a/app/src/androidTest/java/to/bitkit/ui/screens/paymentrequests/CreatePaymentRequestScreenTest.kt b/app/src/androidTest/java/to/bitkit/ui/screens/paymentrequests/CreatePaymentRequestScreenTest.kt index 4e4f3cac9d..5b536fbbc4 100644 --- a/app/src/androidTest/java/to/bitkit/ui/screens/paymentrequests/CreatePaymentRequestScreenTest.kt +++ b/app/src/androidTest/java/to/bitkit/ui/screens/paymentrequests/CreatePaymentRequestScreenTest.kt @@ -20,6 +20,8 @@ import kotlinx.collections.immutable.persistentListOf import org.junit.Rule import org.junit.Test import to.bitkit.models.BITCOIN_SYMBOL +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset import to.bitkit.models.PrimaryDisplay import to.bitkit.models.PubkyProfile import to.bitkit.models.USD_SYMBOL @@ -35,9 +37,9 @@ import to.bitkit.test.annotations.ComposeUi import to.bitkit.ui.LocalCurrencies import to.bitkit.ui.theme.AppThemeSurface import to.bitkit.viewmodels.AmountInputViewModel +import kotlin.test.assertEquals import kotlin.time.ExperimentalTime import kotlin.time.Instant -import kotlin.test.assertEquals @ComposeUi class CreatePaymentRequestScreenTest { @@ -99,7 +101,11 @@ class CreatePaymentRequestScreenTest { composeTestRule.onNodeWithTag("PaymentRequestAmountUnit").performClick() - composeTestRule.onAllNodesWithText(BITCOIN_SYMBOL, substring = true, useUnmergedTree = true).assertCountEquals(1) + composeTestRule.onAllNodesWithText( + BITCOIN_SYMBOL, + substring = true, + useUnmergedTree = true + ).assertCountEquals(1) } @Test @@ -214,7 +220,7 @@ class CreatePaymentRequestScreenTest { } private val draft = PaykitPaymentRequestDraft( - amountSats = 25_000uL, + amount = PaykitAmount(PaykitAsset.BTC, 25_000uL), note = "Dinner", expiresAt = Instant.parse("2027-01-15T09:00:00Z"), ) @@ -226,8 +232,8 @@ class CreatePaymentRequestScreenTest { private val request = PaykitPaymentRequest( paymentRequestId = "payment-request", counterparty = target.publicKey, - amountValue = "0.00025", - amountSats = draft.amountSats, + amount = draft.amount, + paymentReference = "reference", note = draft.note, createdAt = Instant.parse("2027-01-15T08:00:00Z"), expiresAt = Instant.DISTANT_FUTURE, diff --git a/app/src/androidTest/java/to/bitkit/ui/screens/paymentrequests/PaymentRequestsScreenTest.kt b/app/src/androidTest/java/to/bitkit/ui/screens/paymentrequests/PaymentRequestsScreenTest.kt index 4c7808fe97..2056294f6a 100644 --- a/app/src/androidTest/java/to/bitkit/ui/screens/paymentrequests/PaymentRequestsScreenTest.kt +++ b/app/src/androidTest/java/to/bitkit/ui/screens/paymentrequests/PaymentRequestsScreenTest.kt @@ -19,6 +19,9 @@ import kotlinx.collections.immutable.persistentListOf import kotlinx.collections.immutable.persistentSetOf import org.junit.Rule import org.junit.Test +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset +import to.bitkit.models.PaykitRequestPricing import to.bitkit.models.PrimaryDisplay import to.bitkit.models.PubkyProfile import to.bitkit.repositories.CurrencyState @@ -316,8 +319,8 @@ class PaymentRequestsScreenTest { private fun request(id: String = "request") = PaykitPaymentRequest( paymentRequestId = id, counterparty = "pubky3rsduhcxpw74snwyct86m38c63j3pq8x4ycqikxg64roik8yw5xg", - amountValue = "0.00025", - amountSats = 25_000uL, + amount = PaykitAmount(PaykitAsset.BTC, 25_000uL), + paymentReference = "reference-$id", note = "Dinner", createdAt = Instant.parse("2027-01-15T08:00:00Z"), expiresAt = null, @@ -327,8 +330,9 @@ class PaymentRequestsScreenTest { private fun subscription(note: String) = PaykitSubscription( paymentRequestId = "subscription", counterparty = request().counterparty, - amountValue = "0.00025", - amountSats = 25_000uL, + amount = PaykitAmount(PaykitAsset.BTC, 25_000uL), + paymentReference = "invoice", + pricing = PaykitRequestPricing(), note = note, createdAt = Instant.parse("2027-01-15T08:00:00Z"), proposalExpiresAt = null, diff --git a/app/src/androidTest/java/to/bitkit/ui/screens/subscriptions/CreateSubscriptionScreenTest.kt b/app/src/androidTest/java/to/bitkit/ui/screens/subscriptions/CreateSubscriptionScreenTest.kt index cf2aa3c9d5..0fc0ebeeef 100644 --- a/app/src/androidTest/java/to/bitkit/ui/screens/subscriptions/CreateSubscriptionScreenTest.kt +++ b/app/src/androidTest/java/to/bitkit/ui/screens/subscriptions/CreateSubscriptionScreenTest.kt @@ -27,7 +27,11 @@ import com.synonym.paykit.PaymentRequestLifecycleState import kotlinx.collections.immutable.persistentListOf import org.junit.Rule import org.junit.Test +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset +import to.bitkit.models.PaykitRequestPricing import to.bitkit.models.PubkyProfile +import to.bitkit.repositories.MethodId import to.bitkit.repositories.PaykitPaymentRequestDeliveryStatus import to.bitkit.repositories.PaykitPaymentRequestTarget import to.bitkit.repositories.PaykitRecurrenceUnit @@ -55,10 +59,12 @@ class CreateSubscriptionScreenTest { var frequency by mutableStateOf(PaykitRecurrenceUnit.Month) var isLoadingIcon by mutableStateOf(false) var choseRecipient = false + var acceptedMethods by mutableStateOf(persistentListOf(MethodId.P2wpkh.rawValue)) composeTestRule.setContent { AppThemeSurface { CreateSubscriptionDetails( - amountSats = amount, + amount = PaykitAmount(PaykitAsset.BTC, amount), + acceptedMethods = acceptedMethods, name = name, description = "Monthly support", frequency = frequency, @@ -79,11 +85,19 @@ class CreateSubscriptionScreenTest { composeTestRule.onNodeWithTag("SubscriptionChooseRecipient").assertIsNotEnabled() composeTestRule.runOnIdle { amount = 1000uL } composeTestRule.onNodeWithTag("SubscriptionChooseRecipient").assertIsEnabled() - listOf(PaykitRecurrenceUnit.Day, PaykitRecurrenceUnit.Week, PaykitRecurrenceUnit.Month, PaykitRecurrenceUnit.Year) + listOf( + PaykitRecurrenceUnit.Day, + PaykitRecurrenceUnit.Week, + PaykitRecurrenceUnit.Month, + PaykitRecurrenceUnit.Year + ) .forEach { option -> composeTestRule.onNodeWithTag("Tab-${option.name.lowercase()}").performClick() assertEquals(option, frequency) } + composeTestRule.runOnIdle { acceptedMethods = persistentListOf() } + composeTestRule.onNodeWithTag("SubscriptionChooseRecipient").assertIsNotEnabled() + composeTestRule.runOnIdle { acceptedMethods = persistentListOf(MethodId.P2wpkh.rawValue) } composeTestRule.runOnIdle { isLoadingIcon = true } composeTestRule.onNodeWithTag("SubscriptionChooseRecipient").assertIsNotEnabled() composeTestRule.runOnIdle { isLoadingIcon = false } @@ -164,8 +178,9 @@ class CreateSubscriptionScreenTest { private val subscription = PaykitSubscription( paymentRequestId = "creator-proposal", counterparty = target.publicKey, - amountValue = "0.00001", - amountSats = 1000uL, + amount = PaykitAmount(PaykitAsset.BTC, 1000uL), + paymentReference = "invoice", + pricing = PaykitRequestPricing(), note = "Support", createdAt = startsAt, proposalExpiresAt = Instant.parse("2027-01-22T08:00:00Z"), diff --git a/app/src/androidTest/java/to/bitkit/ui/screens/wallets/send/SendConfirmScreenTest.kt b/app/src/androidTest/java/to/bitkit/ui/screens/wallets/send/SendConfirmScreenTest.kt index 0406dd27bf..2f03269716 100644 --- a/app/src/androidTest/java/to/bitkit/ui/screens/wallets/send/SendConfirmScreenTest.kt +++ b/app/src/androidTest/java/to/bitkit/ui/screens/wallets/send/SendConfirmScreenTest.kt @@ -35,6 +35,8 @@ import org.junit.Before import org.junit.Rule import org.junit.Test import to.bitkit.models.FeeRate +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset import to.bitkit.models.PubkyProfile import to.bitkit.repositories.PaykitPaymentRequest import to.bitkit.repositories.PaykitRecurrenceUnit @@ -76,8 +78,8 @@ class SendConfirmScreenTest { val request = PaykitPaymentRequest( paymentRequestId = "preparing", counterparty = "requester", - amountValue = "5000", - amountSats = 5_000u, + amount = PaykitAmount(PaykitAsset.BTC, 5_000u), + paymentReference = "test-reference", note = "Dinner", expiresAt = null, acceptedPaymentEndpointIdentifiers = listOf("bitcoin"), @@ -138,7 +140,7 @@ class SendConfirmScreenTest { assertEquals(SheetValue.Expanded, sheetState.currentValue) assertEquals(1, visibleCount) state.value = SendUiState( - amount = request.amountSats, + amount = request.amount.atomic, isPaymentRequest = true, isAmountInputValid = true, contactPaymentProfile = contact, diff --git a/app/src/main/java/to/bitkit/data/SettingsStore.kt b/app/src/main/java/to/bitkit/data/SettingsStore.kt index 6bb1d5436f..44d2a0e596 100644 --- a/app/src/main/java/to/bitkit/data/SettingsStore.kt +++ b/app/src/main/java/to/bitkit/data/SettingsStore.kt @@ -174,6 +174,7 @@ data class SettingsData( val publicPaykitCleanupPending: Boolean = false, val publicPaykitLightningEnabled: Boolean = true, val publicPaykitOnchainEnabled: Boolean = true, + val publicPaykitUsdtEnabled: Boolean = true, val publicPaykitBolt11: String = "", val publicPaykitBolt11PaymentHash: String = "", val publicPaykitBolt11ExpiresAtMillis: Long = 0, diff --git a/app/src/main/java/to/bitkit/data/keychain/Keychain.kt b/app/src/main/java/to/bitkit/data/keychain/Keychain.kt index 193f2f5d23..f543cfe859 100644 --- a/app/src/main/java/to/bitkit/data/keychain/Keychain.kt +++ b/app/src/main/java/to/bitkit/data/keychain/Keychain.kt @@ -252,6 +252,7 @@ class Keychain @Inject constructor( PAYKIT_PENDING_PAYMENT_PROOFS, ONCHAIN_SEND_ATTEMPT, PAYKIT_ACCEPTED_PAYMENT_REQUESTS, + PAYKIT_USDT_PAYMENTS, PAYKIT_PRESENTED_PAYMENT_REQUESTS, PUBKY_SECRET_KEY, SHARED_PUBKY_SOURCE, diff --git a/app/src/main/java/to/bitkit/env/Env.kt b/app/src/main/java/to/bitkit/env/Env.kt index dd5d4ab8a7..f22b86336b 100644 --- a/app/src/main/java/to/bitkit/env/Env.kt +++ b/app/src/main/java/to/bitkit/env/Env.kt @@ -1,6 +1,7 @@ package to.bitkit.env import android.os.Build +import com.synonym.bitkitcore.UsdtDestination import org.lightningdevkit.ldknode.LogLevel import org.lightningdevkit.ldknode.Network import org.lightningdevkit.ldknode.PeerDetails @@ -17,6 +18,23 @@ import com.synonym.bitkitcore.Network as BitkitCoreNetwork @Suppress("ConstPropertyName", "KotlinConstantConditions", "SimplifyBooleanWithConstants") internal object Env { + val isUsdtEnabled: Boolean get() = (network == Network.BITCOIN || isDebug) && + usdtRpcUrl != null && usdtBundlerUrl.isNotBlank() + val usdtBundlerUrl: String get() = BuildConfig.USDT_BUNDLER_URL + val usdtDepositsUrl: String? get() = BuildConfig.USDT_DEPOSITS_URL.takeIf { it.isNotBlank() } + val usdtBridgesUrl: String? get() = BuildConfig.USDT_BRIDGES_URL.takeIf { it.isNotBlank() } + val usdtRpcUrl: String? get() = BuildConfig.USDT_RPC_URL.takeIf { it.isNotBlank() } + + val usdtDestinations: List get() { + val enabled = BuildConfig.USDT_BRIDGE_NETWORKS.split(',').map { it.trim() }.toSet() + return listOf(UsdtDestination.ARBITRUM) + listOf( + "ethereum" to UsdtDestination.ETHEREUM, + "polygon" to UsdtDestination.POLYGON, + "plasma" to UsdtDestination.PLASMA, + "stable" to UsdtDestination.STABLE, + ).filter { it.first in enabled }.map { it.second } + } + val isDebug = BuildConfig.DEBUG const val isE2eTest = BuildConfig.E2E const val isGeoblockingEnabled = BuildConfig.GEO diff --git a/app/src/main/java/to/bitkit/models/BackupPayloads.kt b/app/src/main/java/to/bitkit/models/BackupPayloads.kt index b5be0c4e61..c52781198c 100644 --- a/app/src/main/java/to/bitkit/models/BackupPayloads.kt +++ b/app/src/main/java/to/bitkit/models/BackupPayloads.kt @@ -24,6 +24,7 @@ data class WalletBackupV1( val paykitSdkBackupState: String? = null, val watchOnlyAccounts: List? = null, val watchOnlyAccountAllocationState: WatchOnlyAccountAllocationState? = null, + val usdtWallet: String? = null, val paykitPaymentState: PaykitPaymentStateBackup? = null, ) diff --git a/app/src/main/java/to/bitkit/models/NewTransactionSheetDetails.kt b/app/src/main/java/to/bitkit/models/NewTransactionSheetDetails.kt index 004c985fd1..0126dd094d 100644 --- a/app/src/main/java/to/bitkit/models/NewTransactionSheetDetails.kt +++ b/app/src/main/java/to/bitkit/models/NewTransactionSheetDetails.kt @@ -12,6 +12,7 @@ data class NewTransactionSheetDetails( val activityId: String? = null, val activityWalletId: String? = null, val sats: Long = 0, + val usdtAmount: ULong? = null, val isLoadingDetails: Boolean = false, ) { companion object { diff --git a/app/src/main/java/to/bitkit/models/PaykitAmount.kt b/app/src/main/java/to/bitkit/models/PaykitAmount.kt new file mode 100644 index 0000000000..7777c76978 --- /dev/null +++ b/app/src/main/java/to/bitkit/models/PaykitAmount.kt @@ -0,0 +1,91 @@ +package to.bitkit.models + +import kotlinx.serialization.Serializable +import to.bitkit.utils.AppError +import java.math.BigDecimal +import java.math.RoundingMode + +@Serializable +enum class PaykitAsset(val code: String, val decimals: Int) { + BTC("btc", 8), + USD("usd", 2), + USDT("usdt", 6), +} + +sealed class PaykitAmountError(message: String) : AppError(message) { + data object InvalidAmount : PaykitAmountError("Invalid payment amount") + data object RateUnavailable : PaykitAmountError("Payment rates are unavailable or expired") +} + +@Serializable +data class PaykitExchangeRate(val price: String, val timestampMillis: Long) { + companion object { + const val MAX_AGE_MILLIS = 10 * 60 * 1000L + private const val MAX_PRICE_DIGITS = 18 + } + + fun value(nowMillis: Long): BigDecimal { + val isFresh = timestampMillis <= nowMillis && nowMillis - timestampMillis <= MAX_AGE_MILLIS + val isDecimal = price.count { it != '.' } <= MAX_PRICE_DIGITS && + price.matches(Regex("[0-9]+(?:\\.[0-9]+)?")) + if (!isFresh || !isDecimal) { + throw PaykitAmountError.RateUnavailable + } + return price.toBigDecimalOrNull()?.takeIf { it > BigDecimal.ZERO } + ?: throw PaykitAmountError.RateUnavailable + } +} + +@Serializable +data class PaykitAmount(val asset: PaykitAsset, val atomic: ULong) { + companion object { + /** Precision shared with the native decimal implementation. */ + private const val MAX_QUOTE_DIGITS = 38 + + /** Maximum accepted decimal rate text length. */ + private const val MAX_RATE_LENGTH = 80 + + fun parse(asset: PaykitAsset, value: String): PaykitAmount { + val scaled = value.takeIf { it.matches(Regex("[0-9]+(?:\\.[0-9]+)?")) } + ?.toBigDecimalOrNull()?.movePointRight(asset.decimals) + ?: throw PaykitAmountError.InvalidAmount + if (scaled.stripTrailingZeros().scale() > 0 || scaled <= BigDecimal.ZERO) { + throw PaykitAmountError.InvalidAmount + } + return PaykitAmount(asset, atomic(scaled)) + } + + private fun atomic(value: BigDecimal): ULong = value.setScale(0, RoundingMode.CEILING) + .toPlainString().toULongOrNull() ?: throw PaykitAmountError.InvalidAmount + } + + val value: String get() = decimalValue().stripTrailingZeros().toPlainString() + + fun convertedTo(paymentAsset: PaykitAsset, rate: PaykitExchangeRate?, nowMillis: Long): PaykitAmount { + val value = valueIn(paymentAsset, rate, nowMillis, paymentAsset.decimals) + return PaykitAmount(paymentAsset, atomic(value.movePointRight(paymentAsset.decimals))) + } + + fun quotedTo(asset: PaykitAsset, multiplier: String): PaykitAmount { + val rate = multiplier.takeIf { + it.length <= MAX_RATE_LENGTH && it.matches(Regex("(?:[0-9]+(?:\\.[0-9]*)?|\\.[0-9]+)")) + }?.toBigDecimalOrNull()?.takeIf { it > BigDecimal.ZERO } + ?: throw PaykitAmountError.RateUnavailable + val product = atomic.toString().toBigDecimal().multiply(rate).stripTrailingZeros() + if (product.precision() > MAX_QUOTE_DIGITS) throw PaykitAmountError.InvalidAmount + return PaykitAmount(asset, atomic(product.scaleByPowerOfTen(asset.decimals - this.asset.decimals))) + } + + private fun valueIn(target: PaykitAsset, rate: PaykitExchangeRate?, nowMillis: Long, scale: Int): BigDecimal { + val amount = decimalValue() + if ((asset == PaykitAsset.BTC) == (target == PaykitAsset.BTC)) return amount + val price = rate?.value(nowMillis) ?: throw PaykitAmountError.RateUnavailable + return if (asset == PaykitAsset.BTC) { + amount.multiply(price) + } else { + amount.divide(price, scale, RoundingMode.CEILING) + } + } + + private fun decimalValue() = atomic.toString().toBigDecimal().movePointLeft(asset.decimals) +} diff --git a/app/src/main/java/to/bitkit/models/PaykitPaymentStateBackup.kt b/app/src/main/java/to/bitkit/models/PaykitPaymentStateBackup.kt index efbdb50c7e..7cb9da325c 100644 --- a/app/src/main/java/to/bitkit/models/PaykitPaymentStateBackup.kt +++ b/app/src/main/java/to/bitkit/models/PaykitPaymentStateBackup.kt @@ -17,6 +17,7 @@ data class PaykitPaymentStateBackup( val subscriptions: Map, val pendingProofs: List, val activeOnchainAttempt: ActiveOnchainAttemptBackup? = null, + val usdt: PaykitUsdtStateBackup? = null, val acceptedOneTimeRequests: Map>? = null, ) { @Serializable @@ -48,6 +49,7 @@ data class PaykitPaymentStateBackup( val paymentStarted: Boolean, val paymentIdentifier: String? = null, val proofData: String? = null, + val conversionQuoteId: String? = null, val billingPeriod: PaykitBillingPeriod? = null, val onchainAddress: String? = null, val onchainAmountSats: ULong? = null, @@ -78,6 +80,7 @@ data class PaykitPaymentStateBackup( paymentStarted = proof.paymentStarted, paymentIdentifier = proof.paymentIdentifier, proofData = proof.proofData, + conversionQuoteId = proof.conversionQuoteId, billingPeriod = proof.billingPeriod, onchainAddress = proof.onchainAddress, onchainAmountSats = proof.onchainAmountSats, @@ -102,6 +105,7 @@ data class PaykitPaymentStateBackup( paymentStarted = paymentStarted, paymentIdentifier = paymentIdentifier, proofData = proofData, + conversionQuoteId = conversionQuoteId, billingPeriod = billingPeriod, onchainAddress = onchainAddress, onchainAmountSats = onchainAmountSats, diff --git a/app/src/main/java/to/bitkit/models/PaykitRequestPricing.kt b/app/src/main/java/to/bitkit/models/PaykitRequestPricing.kt new file mode 100644 index 0000000000..1168f65732 --- /dev/null +++ b/app/src/main/java/to/bitkit/models/PaykitRequestPricing.kt @@ -0,0 +1,136 @@ +@file:OptIn(kotlin.time.ExperimentalTime::class) + +package to.bitkit.models + +import com.synonym.paykit.ConversionRate +import com.synonym.paykit.PaymentConversion +import com.synonym.paykit.PaymentConversionQuoteRecord +import com.synonym.paykit.PaymentDeadline +import kotlinx.serialization.Serializable +import to.bitkit.repositories.MethodId +import to.bitkit.repositories.PaykitBillingPeriod +import java.math.BigDecimal +import java.math.RoundingMode +import kotlin.time.Duration.Companion.seconds +import kotlin.time.Instant + +/** Market rates are only used when creating request terms. */ +data class PaykitRequestPricing( + val conversion: PaymentConversion? = null, + val deadline: PaymentDeadline? = null, + val quotes: List = emptyList(), +) { + fun payment( + requested: PaykitAmount, + asset: PaykitAsset, + period: PaykitBillingPeriod?, + at: Instant, + quoteId: String? = null, + ): PaykitRequestPayment { + val deadline = paymentDeadline(period) + if (requested.asset == asset) { + if (quoteId != null) throw PaykitAmountError.InvalidAmount + return PaykitRequestPayment(requested, null, null, deadline) + } + val (rates, selected) = conversionRates(period, at, quoteId) + val rate = rates.firstOrNull { it.asset == asset.code } ?: throw PaykitAmountError.RateUnavailable + return PaykitRequestPayment( + amount = requested.quotedTo(asset, rate.value), + quoteId = selected?.eventId, + validFrom = selected?.let { Instant.parse(it.validFrom) }, + expiresAt = listOfNotNull(deadline, selected?.let { Instant.parse(it.expiresAt) }).minOrNull(), + ) + } + + private fun conversionRates( + period: PaykitBillingPeriod?, + at: Instant, + quoteId: String?, + ): Pair, PaymentConversionQuoteRecord?> { + var selected: PaymentConversionQuoteRecord? = null + val rates = when (val terms = conversion) { + is PaymentConversion.Fixed -> { + if (quoteId != null) throw PaykitAmountError.InvalidAmount + terms.rates + } + PaymentConversion.PerPeriod -> { + selected = periodQuote(period, at, quoteId) + selected.rates + } + null -> throw PaykitAmountError.RateUnavailable + } + return rates to selected + } + + private fun periodQuote(period: PaykitBillingPeriod?, at: Instant, quoteId: String?): PaymentConversionQuoteRecord { + if (period == null) throw PaykitAmountError.InvalidAmount + return quotes.lastOrNull { + Instant.parse(it.billingPeriod.startsAt) == period.startsAt && + Instant.parse(it.billingPeriod.endsAt) == period.endsAt && + if (quoteId != null) { + it.eventId == quoteId + } else { + at >= Instant.parse(it.validFrom) && at <= Instant.parse(it.expiresAt) + } + } ?: throw PaykitAmountError.RateUnavailable + } + + fun paymentDeadline(period: PaykitBillingPeriod?): Instant? = when (val value = deadline) { + null -> null + is PaymentDeadline.At -> { + if (period != null) throw PaykitAmountError.InvalidAmount + Instant.parse(value.timestamp) + } + is PaymentDeadline.PeriodStart -> { + if (period == null || value.seconds > Long.MAX_VALUE.toULong()) throw PaykitAmountError.InvalidAmount + period.startsAt + value.seconds.toLong().seconds + } + } + + companion object { + fun subscriptionEndpoints(requested: PaykitAsset, available: List): List = available.filter { + val method = MethodId.fromRawValue(it) ?: return@filter false + when (requested) { + PaykitAsset.BTC -> method != MethodId.UsdtArbitrum + PaykitAsset.USD -> method == MethodId.UsdtArbitrum + PaykitAsset.USDT -> false + } + } + + fun rates( + requested: PaykitAsset, + endpoints: List, + market: PaykitExchangeRate?, + at: Instant, + ): List = endpoints.mapNotNull { MethodId.fromRawValue(it) } + .map { if (it == MethodId.UsdtArbitrum) PaykitAsset.USDT else PaykitAsset.BTC } + .distinct().sortedBy { it.code }.filter { it != requested }.map { asset -> + val value = if ((requested == PaykitAsset.BTC) != (asset == PaykitAsset.BTC)) { + val price = market?.value(at.toEpochMilliseconds()) ?: throw PaykitAmountError.RateUnavailable + if (requested == PaykitAsset.BTC) { + price + } else { + BigDecimal.ONE.divide( + price, + 18, + RoundingMode.HALF_EVEN + ) + } + } else { + BigDecimal.ONE + } + if (value <= BigDecimal.ZERO) throw PaykitAmountError.RateUnavailable + ConversionRate(asset.code, value.stripTrailingZeros().toPlainString()) + } + } +} + +@Serializable +data class PaykitRequestPayment( + val amount: PaykitAmount, + val quoteId: String?, + val validFrom: Instant?, + val expiresAt: Instant?, +) { + fun isValid(at: Instant): Boolean = (validFrom == null || at >= validFrom) && (expiresAt == null || at <= expiresAt) +} diff --git a/app/src/main/java/to/bitkit/models/PaykitUsdt.kt b/app/src/main/java/to/bitkit/models/PaykitUsdt.kt new file mode 100644 index 0000000000..e2fefa70c9 --- /dev/null +++ b/app/src/main/java/to/bitkit/models/PaykitUsdt.kt @@ -0,0 +1,54 @@ +package to.bitkit.models + +import com.synonym.bitkitcore.usdtParsePaymentRequest +import kotlinx.serialization.json.Json +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.JsonPrimitive +import kotlinx.serialization.json.contentOrNull +import kotlinx.serialization.json.jsonObject +import kotlinx.serialization.json.jsonPrimitive +import to.bitkit.repositories.Endpoint +import to.bitkit.repositories.MethodId +import to.bitkit.repositories.PublicPaykitError + +object PaykitUsdt { + /** Arbitrum One's chain identifier. */ + const val CHAIN_ID = "42161" + + /** USDT0's pinned Arbitrum token contract. */ + const val TOKEN = "0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9" + + private const val ADDRESS_LENGTH = 42 + + fun address(payload: String): String? = runCatching { + val fields = Json.parseToJsonElement(payload).jsonObject + val hasStringFields = listOf("chain_id", "token", "value").all { fields[it]?.jsonPrimitive?.isString == true } + if (!hasStringFields) return@runCatching null + if (fields["chain_id"]?.jsonPrimitive?.contentOrNull != CHAIN_ID || + fields["token"]?.jsonPrimitive?.contentOrNull?.lowercase() != TOKEN + ) { + return@runCatching null + } + val value = fields["value"]?.jsonPrimitive?.contentOrNull ?: return@runCatching null + if (value.length != ADDRESS_LENGTH) return@runCatching null + usdtParsePaymentRequest(value).takeIf { it.chainId == null && it.amount == null }?.recipient + }.getOrNull() + + fun endpoint(address: String): Endpoint { + val payload = JsonObject( + mapOf( + "value" to JsonPrimitive(address), + "chain_id" to JsonPrimitive(CHAIN_ID), + "token" to JsonPrimitive(TOKEN) + ) + ) + .toString() + return Endpoint( + methodId = MethodId.UsdtArbitrum, + value = address(payload) ?: throw PublicPaykitError.InvalidPayload, + rawPayload = payload, + ) + } + + fun paymentUri(address: String): String = "ethereum:$TOKEN@$CHAIN_ID/transfer?address=$address" +} diff --git a/app/src/main/java/to/bitkit/models/PaykitUsdtStateBackup.kt b/app/src/main/java/to/bitkit/models/PaykitUsdtStateBackup.kt new file mode 100644 index 0000000000..03e4a1c3ae --- /dev/null +++ b/app/src/main/java/to/bitkit/models/PaykitUsdtStateBackup.kt @@ -0,0 +1,38 @@ +package to.bitkit.models + +import kotlinx.serialization.Serializable +import to.bitkit.repositories.PaykitPaymentRequestId +import to.bitkit.repositories.PaykitUsdtAttempt +import to.bitkit.repositories.PaykitUsdtReceipt + +@Serializable +data class PaykitUsdtStateBackup( + val attempts: List, + val receipts: List, +) { + @Serializable + data class Receipt( + val wallet: String, + val identity: String, + val requestId: PaykitPaymentRequestId, + val paymentId: String, + val proofEventId: String, + val verified: Boolean, + val transferId: String, + val amountAtomic: ULong, + val receivedAtMillis: Long, + val underpaid: Boolean, + val afterExpiry: Boolean, + ) { + constructor(value: PaykitUsdtReceipt) : this( + value.wallet, value.identity, value.requestId, value.paymentId, value.proofEventId, + value.verified, value.transferId, value.amount.atomic, value.receivedAtMillis, + value.underpaid, value.afterExpiry, + ) + + fun restored() = PaykitUsdtReceipt( + wallet, identity, requestId, paymentId, proofEventId, verified, transferId, + PaykitAmount(PaykitAsset.USDT, amountAtomic), receivedAtMillis, underpaid, afterExpiry, + ) + } +} diff --git a/app/src/main/java/to/bitkit/models/PubkyAuthClaimCodec.kt b/app/src/main/java/to/bitkit/models/PubkyAuthClaimCodec.kt index 7fe7b28ab3..df9001b951 100644 --- a/app/src/main/java/to/bitkit/models/PubkyAuthClaimCodec.kt +++ b/app/src/main/java/to/bitkit/models/PubkyAuthClaimCodec.kt @@ -13,6 +13,10 @@ object PubkyAuthClaimCodec { const val COMBINED_PAYLOAD_LENGTH = 124 fun validateAccountPayload(claim: PubkyAuthClaim, accountPayload: ByteArray) { + if (claim.sharesUsdt) { + require(!claim.includesPaykitAccess && accountPayload.isNotEmpty()) { "Invalid payment-details claim" } + return + } if (!claim.includesWatchOnlyAccount) { require(accountPayload.isEmpty()) { "Paykit-only approval cannot include an account" } return diff --git a/app/src/main/java/to/bitkit/models/PubkyAuthRequest.kt b/app/src/main/java/to/bitkit/models/PubkyAuthRequest.kt index 0953f9b4c9..a632b75910 100644 --- a/app/src/main/java/to/bitkit/models/PubkyAuthRequest.kt +++ b/app/src/main/java/to/bitkit/models/PubkyAuthRequest.kt @@ -3,6 +3,12 @@ package to.bitkit.models import androidx.compose.runtime.Immutable import kotlinx.collections.immutable.ImmutableList import kotlinx.collections.immutable.toImmutableList +import kotlinx.serialization.json.Json +import kotlinx.serialization.json.buildJsonObject +import kotlinx.serialization.json.jsonObject +import kotlinx.serialization.json.put +import to.bitkit.repositories.Endpoint +import to.bitkit.repositories.MethodId import to.bitkit.utils.AppError import java.net.URI import java.net.URLDecoder @@ -21,13 +27,47 @@ value class PubkyAuthClaim private constructor(val items: ImmutableList) { enum class Item(val wireValue: String) { PAYKIT_ACCESS_V1("paykit-access-v1"), WATCH_ONLY_ACCOUNT_V1("watch-only-account-v1"), + USDT_ADDRESS_V1("usdt-address-v1"), + PAYMENT_DETAILS_V1("payment-details-v1"), } val wireValue: String get() = items.joinToString(".") { it.wireValue } - val includesWatchOnlyAccount: Boolean get() = Item.WATCH_ONLY_ACCOUNT_V1 in items + val includesWatchOnlyAccount: Boolean + get() = Item.WATCH_ONLY_ACCOUNT_V1 in items || Item.PAYMENT_DETAILS_V1 in items val includesPaykitAccess: Boolean get() = Item.PAYKIT_ACCESS_V1 in items + val sharesBitcoin: Boolean get() = includesWatchOnlyAccount + val sharesUsdt: Boolean get() = Item.USDT_ADDRESS_V1 in items || Item.PAYMENT_DETAILS_V1 in items + val sharesReceivingDetails: Boolean get() = sharesBitcoin || sharesUsdt + + fun unsignedPayload(bitcoin: PreparedWatchOnlyAccountClaim?, usdt: Endpoint?): ByteArray { + if (sharesBitcoin && bitcoin == null) throw PubkyAuthRequestError.InvalidPaymentDetails + if (!sharesUsdt) return bitcoin?.payload ?: byteArrayOf() + if (usdt == null || usdt.methodId != MethodId.UsdtArbitrum || + PaykitUsdt.address(usdt.rawPayload) != usdt.value + ) { + throw PubkyAuthRequestError.InvalidPaymentDetails + } + return buildJsonObject { + put(MethodId.UsdtArbitrum.rawValue, Json.parseToJsonElement(usdt.rawPayload).jsonObject) + if (sharesBitcoin) { + val account = checkNotNull(bitcoin).account + put( + "bitcoin_account", + buildJsonObject { + put("account_index", account.accountIndex) + put("address_type", account.addressType) + put("xpub", account.xpub) + } + ) + } + }.toString().encodeToByteArray() + } + companion object { + val USDT_ADDRESS_V1 = PubkyAuthClaim(Item.USDT_ADDRESS_V1) + val PAYMENT_DETAILS_V1 = PubkyAuthClaim(Item.PAYMENT_DETAILS_V1) + /** Query parameter used for Bitkit-specific Pubky auth claims. */ const val QUERY_PARAMETER = "x-bitkit-claim" @@ -44,6 +84,8 @@ value class PubkyAuthClaim private constructor(val items: ImmutableList) { Item.entries.firstOrNull { it.wireValue == token } ?: return null } if (items.distinct().size != items.size) return null + val hasStandaloneClaim = items.any { it == Item.USDT_ADDRESS_V1 || it == Item.PAYMENT_DETAILS_V1 } + if (items.size != 1 && hasStandaloneClaim) return null return PubkyAuthClaim(items.toImmutableList()) } } @@ -51,6 +93,7 @@ value class PubkyAuthClaim private constructor(val items: ImmutableList) { sealed class PubkyAuthRequestError(cause: Throwable? = null) : AppError(cause = cause) { class InvalidUrl(cause: Throwable) : PubkyAuthRequestError(cause) + data object InvalidPaymentDetails : PubkyAuthRequestError() data object RequesterChanged : PubkyAuthRequestError() data object MissingBitkitClaim : PubkyAuthRequestError() data object DuplicateBitkitClaim : PubkyAuthRequestError() diff --git a/app/src/main/java/to/bitkit/repositories/BackupRepo.kt b/app/src/main/java/to/bitkit/repositories/BackupRepo.kt index 4512fdda2a..a0e78a05e9 100644 --- a/app/src/main/java/to/bitkit/repositories/BackupRepo.kt +++ b/app/src/main/java/to/bitkit/repositories/BackupRepo.kt @@ -1,6 +1,7 @@ package to.bitkit.repositories import android.content.Context +import com.synonym.bitkitcore.UsdtException import dagger.hilt.android.qualifiers.ApplicationContext import kotlinx.coroutines.CoroutineDispatcher import kotlinx.coroutines.FlowPreview @@ -22,6 +23,8 @@ import kotlinx.coroutines.flow.map import kotlinx.coroutines.flow.update import kotlinx.coroutines.isActive import kotlinx.coroutines.launch +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock import kotlinx.coroutines.withContext import kotlinx.coroutines.withTimeout import kotlinx.serialization.Serializable @@ -114,6 +117,8 @@ class BackupRepo @Inject constructor( private val privatePaykitRepo: Provider, private val privatePaykitAddressReservationRepo: Provider, private val paykitPaymentProofRepo: Provider, + private val paykitUsdtPaymentRepo: Provider, + private val usdtRepo: Provider, private val paykitPaymentProofStore: PaykitPaymentProofStore, private val paykitPaymentRequestRepo: Provider, private val paykitPresentationStore: PaykitPaymentRequestPresentationStore, @@ -127,6 +132,7 @@ class BackupRepo @Inject constructor( private val clock: Clock, private val db: AppDb, ) { + private val walletBackupMutex = Mutex() private val scope = appScope(ioDispatcher, TAG) private val backupJobs = mutableMapOf() @@ -370,6 +376,15 @@ class BackupRepo @Inject constructor( dataListenerJobs.add(observeBackupChanges(paykitSdkService.backupStateVersion, BackupCategory.WALLET)) dataListenerJobs.add(observeBackupChanges(paykitPaymentProofStore.backupStateVersion, BackupCategory.WALLET)) dataListenerJobs.add(observeBackupChanges(onchainSendAttemptStore.backupStateVersion, BackupCategory.WALLET)) + dataListenerJobs.add( + observeBackupChanges(paykitUsdtPaymentRepo.get().backupStateVersion, BackupCategory.WALLET) + ) + dataListenerJobs.add( + observeBackupChanges( + usdtRepo.get().state.map { it.transfers }.distinctUntilChanged(), + BackupCategory.WALLET, + ) + ) dataListenerJobs.add(observeBackupChanges(paykitPresentationStore.backupStateVersion, BackupCategory.WALLET)) dataListenerJobs.add( observeBackupChanges( @@ -521,12 +536,15 @@ class BackupRepo @Inject constructor( backupRequired = maxOf(backupRequired, it.required, it.synced + 1) it.copy(running = true, required = backupRequired) } - val data = runSuspendCatching { getBackupDataBytes(category) } - .getOrElse { - markBackupFailed(category, backupRequired, it) - return@withContext Result.failure(it) + + val upload = if (category == BackupCategory.WALLET) { + persistWalletBackup() + } else { + runSuspendCatching { + vssBackupClient.putObject(key = category.name, data = getBackupDataBytes(category)).getOrThrow() } - vssBackupClient.putObject(key = category.name, data = data) + } + upload .onSuccess { withContext(NonCancellable) { cacheStore.updateBackupStatus(category) { @@ -548,6 +566,17 @@ class BackupRepo @Inject constructor( } } + suspend fun persistWalletBackup(usdt: String? = null): Result = withContext(ioDispatcher) { + runSuspendCatching { + walletBackupMutex.withLock { + if (shouldSkipBackup()) throw UsdtException.BackupUnavailable() + vssBackupClient.setup().getOrThrow() + val data = getWalletBackupDataBytes(usdt) + vssBackupClient.putObject(key = BackupCategory.WALLET.name, data = data).getOrThrow() + } + }.map { }.onFailure { markBackupRequired(BackupCategory.WALLET) } + } + private suspend fun markBackupFailed(category: BackupCategory, backupRequired: Long, e: Throwable) { withContext(NonCancellable) { cacheStore.updateBackupStatus(category) { @@ -646,7 +675,7 @@ class BackupRepo @Inject constructor( json.encodeToString(payload).toByteArray() } - private suspend fun getWalletBackupDataBytes(): ByteArray { + private suspend fun getWalletBackupDataBytes(usdt: String? = null): ByteArray { check(!keychain.exists(Keychain.Key.PAYKIT_PENDING_BACKUP_RESTORE.name)) { "Wallet backup restore is incomplete" } @@ -693,10 +722,12 @@ class BackupRepo @Inject constructor( paykitSdkBackupState = paykitSdkBackupState, watchOnlyAccounts = watchOnlyAccountSnapshot.accounts, watchOnlyAccountAllocationState = watchOnlyAccountSnapshot.allocationState, + usdtWallet = usdt ?: usdtRepo.get().backupSnapshot(), paykitPaymentState = PaykitPaymentStateBackup( subscriptions = paykitPresentationStore.backupSnapshot(), pendingProofs = proofs, activeOnchainAttempt = active, + usdt = paykitUsdtPaymentRepo.get().backupSnapshot(), acceptedOneTimeRequests = paykitPresentationStore.acceptedOneTimeBackupSnapshot(), ), ) @@ -835,6 +866,7 @@ class BackupRepo @Inject constructor( keychain.upsertString(Keychain.Key.PAYKIT_PENDING_BACKUP_RESTORE.name, String(dataBytes)) val parsed = json.decodeFromString(String(dataBytes)) var restoredAttempt: OnchainSendAttempt? = null + parsed.usdtWallet?.let { usdtRepo.get().restoreBackup(it).getOrThrow() } parsed.paykitPaymentState?.let { // Validate every proof before writing a guard or replacing existing payment state. it.pendingProofs.forEach { proof -> proof.restored() } @@ -859,6 +891,7 @@ class BackupRepo @Inject constructor( paykitPaymentRequestRepo.get().clear() paykitPresentationStore.restoreBackup(it.subscriptions) paykitPaymentProofRepo.get().restoreBackup(it.pendingProofs) + it.usdt?.let { usdt -> paykitUsdtPaymentRepo.get().restoreBackup(usdt) } paykitPresentationStore.restoreAcceptedOneTimeRequests(it.acceptedOneTimeRequests.orEmpty()) } db.transferDao().upsert(parsed.transfers) diff --git a/app/src/main/java/to/bitkit/repositories/ContactPaymentSettingsRepo.kt b/app/src/main/java/to/bitkit/repositories/ContactPaymentSettingsRepo.kt index 19b9e789c2..1145ebfad9 100644 --- a/app/src/main/java/to/bitkit/repositories/ContactPaymentSettingsRepo.kt +++ b/app/src/main/java/to/bitkit/repositories/ContactPaymentSettingsRepo.kt @@ -88,6 +88,7 @@ class ContactPaymentSettingsRepo @Inject constructor( sharesPrivatePaykitEndpoints = canUsePrivateContactPayments, publicPaykitLightningEnabled = true, publicPaykitOnchainEnabled = true, + publicPaykitUsdtEnabled = true, ) } publicPaykitRepo.syncPublishedEndpoints(publish = true).getOrThrow() @@ -120,6 +121,7 @@ class ContactPaymentSettingsRepo @Inject constructor( sharesPrivatePaykitEndpoints = previous.sharesPrivatePaykitEndpoints, publicPaykitLightningEnabled = previous.publicPaykitLightningEnabled, publicPaykitOnchainEnabled = previous.publicPaykitOnchainEnabled, + publicPaykitUsdtEnabled = previous.publicPaykitUsdtEnabled, ) } }.onFailure(error::addSuppressed) @@ -149,6 +151,7 @@ class ContactPaymentSettingsRepo @Inject constructor( sharesPrivatePaykitEndpoints = false, publicPaykitLightningEnabled = true, publicPaykitOnchainEnabled = true, + publicPaykitUsdtEnabled = true, ) } }.onFailure { diff --git a/app/src/main/java/to/bitkit/repositories/CurrencyRepo.kt b/app/src/main/java/to/bitkit/repositories/CurrencyRepo.kt index ff7b411259..e8008b283b 100644 --- a/app/src/main/java/to/bitkit/repositories/CurrencyRepo.kt +++ b/app/src/main/java/to/bitkit/repositories/CurrencyRepo.kt @@ -275,6 +275,11 @@ data class CurrencyState( val lastSuccessfulRefresh: Long? = null, ) +val CurrencyState.paykitRate: to.bitkit.models.PaykitExchangeRate? + get() = rates.firstOrNull { + it.quote == "USD" + }?.let { to.bitkit.models.PaykitExchangeRate(it.lastPrice, it.lastUpdatedAt) } + interface AmountInputHandler { fun convertSatsToFiatString(sats: Long): String fun convertFiatToSats(fiat: Double): Long diff --git a/app/src/main/java/to/bitkit/repositories/PaykitPaymentProofRepo.kt b/app/src/main/java/to/bitkit/repositories/PaykitPaymentProofRepo.kt index 1766aeee88..22bfc64701 100644 --- a/app/src/main/java/to/bitkit/repositories/PaykitPaymentProofRepo.kt +++ b/app/src/main/java/to/bitkit/repositories/PaykitPaymentProofRepo.kt @@ -22,9 +22,7 @@ import kotlinx.serialization.json.Json import kotlinx.serialization.json.JsonObject import kotlinx.serialization.json.JsonPrimitive import kotlinx.serialization.json.buildJsonObject -import kotlinx.serialization.json.contentOrNull import kotlinx.serialization.json.jsonObject -import kotlinx.serialization.json.jsonPrimitive import org.lightningdevkit.ldknode.NodeException import org.lightningdevkit.ldknode.PaymentDetails import org.lightningdevkit.ldknode.PaymentDirection @@ -36,6 +34,7 @@ import to.bitkit.ext.runSuspendCatching import to.bitkit.ext.toHex import to.bitkit.models.HwFundingSignedTx import to.bitkit.models.PaykitPaymentStateBackup +import to.bitkit.models.PaykitRequestPayment import to.bitkit.models.PubkyPublicKeyFormat import to.bitkit.models.WalletScope import to.bitkit.services.PaykitSdkService @@ -53,12 +52,13 @@ import kotlin.time.Instant @Serializable enum class PaykitPaymentProofKind(val type: String) { Lightning("bitcoin-bolt11-preimage"), - Onchain("bitcoin-onchain-txid"); + Onchain("bitcoin-onchain-txid"), + Usdt("erc20-transfer-eip712"); companion object { fun fromPaymentEndpointIdentifier(identifier: String): PaykitPaymentProofKind? { val method = MethodId.fromRawValue(identifier) ?: return null - return if (method.isOnchain) Onchain else Lightning + return if (method == MethodId.UsdtArbitrum) Usdt else if (method.isOnchain) Onchain else Lightning } } } @@ -79,6 +79,7 @@ data class PendingPaykitPaymentProof( val paymentStarted: Boolean = false, val paymentIdentifier: String? = null, val proofData: String? = null, + val conversionQuoteId: String? = null, val billingPeriod: PaykitBillingPeriod? = null, val onchainAddress: String? = null, val onchainAmountSats: ULong? = null, @@ -175,13 +176,19 @@ class PaykitPaymentProofRepo @Inject constructor( paymentEndpointIdentifier: String, paymentAppId: String, kind: PaykitPaymentProofKind, + paymentTerms: PaykitRequestPayment? = null, ): Result = withContext(ioDispatcher) { runSuspendCatching { releaseInterruptedShopPreparation() val onchainAttempt = lightningRepo.currentOnchainSendAttempt() if (onchainAttempt?.requestId == request.id) throw PaykitPaymentRequestError.OperationInProgress operationMutex.withLock { - val proof = pendingProof(request, paymentEndpointIdentifier, paymentAppId, kind) + val proof = pendingProof( + request, + paymentEndpointIdentifier, + paymentAppId, + kind + ).copy(conversionQuoteId = paymentTerms?.quoteId) val currentProofs = loadProofs() if (currentProofs.any { it.isStartedFor(proof.identity, request.id) || @@ -251,6 +258,7 @@ class PaykitPaymentProofRepo @Inject constructor( suspend fun markOnchainPaymentStarted( request: PaykitPaymentRequest, address: String, + amountSats: ULong, walletId: String = WalletScope.default, privatePaymentListVersion: ULong? = null, signedTx: HwFundingSignedTx? = null, @@ -279,7 +287,7 @@ class PaykitPaymentProofRepo @Inject constructor( proofs[index] = proofs[index].copy( paymentStarted = true, onchainAddress = address, - onchainAmountSats = request.amountSats, + onchainAmountSats = amountSats, onchainWalletId = walletId, privatePaymentListVersion = privatePaymentListVersion, previousPrivatePaymentListVersion = previousPrivatePaymentListVersion.takeIf { @@ -402,6 +410,7 @@ class PaykitPaymentProofRepo @Inject constructor( txid: String, paymentEndpointIdentifier: String, paymentAppId: String, + conversionQuoteId: String? = null, acceptedOutcome: OnchainSendOutcome.Accepted? = null, ): Boolean = withContext(ioDispatcher) { if (!txid.isHex(HASH_BYTE_COUNT)) { @@ -474,7 +483,7 @@ class PaykitPaymentProofRepo @Inject constructor( onchainAcceptanceVerified = true, ) } else { - pendingProof(request, paymentEndpointIdentifier, paymentAppId, PaykitPaymentProofKind.Onchain).copy( + pendingOnchainProof(request, paymentEndpointIdentifier, paymentAppId, conversionQuoteId).copy( paymentStarted = true, paymentIdentifier = txid.lowercase(), proofData = txid.lowercase(), @@ -1176,6 +1185,10 @@ class PaykitPaymentProofRepo @Inject constructor( ?.publicKey ?.let(PubkyPublicKeyFormat::normalized) + suspend fun submit(proof: PendingPaykitPaymentProof): Result = withContext(ioDispatcher) { + operationMutex.withLock { runSuspendCatching { submitReady(proof) } } + } + private suspend fun submitReady(proof: PendingPaykitPaymentProof): Boolean { // Missing legacy app provenance must remain readable, never guessed for delivery. if (proof.paymentAppId.isBlank()) return false @@ -1198,6 +1211,7 @@ class PaykitPaymentProofRepo @Inject constructor( it.billingPeriod.matches(proof.billingPeriod) && it.paymentEndpointIdentifier == proof.paymentEndpointIdentifier && it.paymentAppId == proof.paymentAppId && + it.conversionQuoteId == proof.conversionQuoteId && it.proof.exportText().proofValues() == proofJson.proofValues() } if (!alreadyQueued) { @@ -1207,6 +1221,7 @@ class PaykitPaymentProofRepo @Inject constructor( paymentEndpointIdentifier = proof.paymentEndpointIdentifier, paymentAppId = proof.paymentAppId, proofJson = proofJson, + conversionQuoteId = proof.conversionQuoteId, billingPeriod = proof.billingPeriod, ) Logger.info("Queued a Paykit payment proof for private delivery", context = TAG) @@ -1219,11 +1234,13 @@ class PaykitPaymentProofRepo @Inject constructor( ) } } - runSuspendCatching { - removeProofsLocked { - PubkyPublicKeyFormat.matches(it.identity, proof.identity) && it.requestId == proof.requestId - } - }.onFailure { Logger.warn("Failed to clear a submitted Paykit payment proof", it, context = TAG) } + if (proof.kind != PaykitPaymentProofKind.Usdt) { + runSuspendCatching { + removeProofsLocked { + PubkyPublicKeyFormat.matches(it.identity, proof.identity) && it.requestId == proof.requestId + } + }.onFailure { Logger.warn("Failed to clear a submitted Paykit payment proof", it, context = TAG) } + } return true } @@ -1303,6 +1320,13 @@ class PaykitPaymentProofRepo @Inject constructor( return didPersist || !hasUndeliveredProof } + private suspend fun pendingOnchainProof( + request: PaykitPaymentRequest, + endpoint: String, + appId: String, + quoteId: String?, + ) = pendingProof(request, endpoint, appId, PaykitPaymentProofKind.Onchain).copy(conversionQuoteId = quoteId) + private suspend fun pendingProof( request: PaykitPaymentRequest, paymentEndpointIdentifier: String, @@ -1358,6 +1382,7 @@ private fun endpointSupports(identifier: String, kind: PaykitPaymentProofKind): return when (kind) { PaykitPaymentProofKind.Lightning -> method == MethodId.Bolt11 || method == MethodId.Lnurl PaykitPaymentProofKind.Onchain -> method.isOnchain + PaykitPaymentProofKind.Usdt -> method == MethodId.UsdtArbitrum } } @@ -1377,19 +1402,15 @@ private fun PendingPaykitPaymentProof.isUnstartedFor( paymentIdentifier == null && proofData == null -private fun proofJson(kind: PaykitPaymentProofKind, data: String): String = buildJsonObject { - put("data", JsonPrimitive(data)) - put("type", JsonPrimitive(kind.type)) -}.toString() +private fun proofJson(kind: PaykitPaymentProofKind, data: String): String { + if (kind == PaykitPaymentProofKind.Usdt) return data + return buildJsonObject { + put("data", JsonPrimitive(data)) + put("type", JsonPrimitive(kind.type)) + }.toString() +} -private fun String.proofValues(): JsonObject? = runCatching { - Json.parseToJsonElement(this).jsonObject.let { values -> - buildJsonObject { - values["data"]?.jsonPrimitive?.contentOrNull?.let { put("data", JsonPrimitive(it)) } - values["type"]?.jsonPrimitive?.contentOrNull?.let { put("type", JsonPrimitive(it)) } - } - } -}.getOrNull() +private fun String.proofValues(): JsonObject? = runCatching { Json.parseToJsonElement(this).jsonObject }.getOrNull() private fun String.matchesPaymentHash(paymentHash: String): Boolean { val preimage = hexBytes() ?: return false diff --git a/app/src/main/java/to/bitkit/repositories/PaykitPaymentRequestRepo.kt b/app/src/main/java/to/bitkit/repositories/PaykitPaymentRequestRepo.kt index 632b81a791..949bc10695 100644 --- a/app/src/main/java/to/bitkit/repositories/PaykitPaymentRequestRepo.kt +++ b/app/src/main/java/to/bitkit/repositories/PaykitPaymentRequestRepo.kt @@ -7,6 +7,7 @@ import com.synonym.paykit.LinkedPeerState import com.synonym.paykit.OutboundPrivateCounterpartySendReport import com.synonym.paykit.OutboundPrivateMessageStatus import com.synonym.paykit.PaykitException +import com.synonym.paykit.PaymentConversion import com.synonym.paykit.PaymentDeadline import com.synonym.paykit.PaymentRequestLifecycleState import com.synonym.paykit.PaymentRequestLocalRole @@ -50,6 +51,10 @@ import to.bitkit.di.SubscriptionClock import to.bitkit.env.Env import to.bitkit.ext.runSuspendCatching import to.bitkit.flags.PaykitFeatureFlags +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset +import to.bitkit.models.PaykitRequestPayment +import to.bitkit.models.PaykitRequestPricing import to.bitkit.models.PubkyPublicKeyFormat import to.bitkit.models.satsToMsat import to.bitkit.services.PaykitPaymentRequestProposalTerms @@ -82,8 +87,9 @@ data class PaykitPaymentRequestId( data class PaykitPaymentRequest( val paymentRequestId: String, val counterparty: String, - val amountValue: String, - val amountSats: ULong, + val amount: PaykitAmount, + val paymentReference: String, + val pricing: PaykitRequestPricing = PaykitRequestPricing(), val note: String? = null, val createdAt: Instant? = null, val expiresAt: Instant?, @@ -97,6 +103,11 @@ data class PaykitPaymentRequest( val isPaymentInFlight: Boolean = false, val proposalStreamItemId: ULong? = null, ) { + val amountValue: String get() = amount.value + + fun payment(asset: PaykitAsset, at: Instant, quoteId: String? = null): PaykitRequestPayment = + pricing.payment(amount, asset, billingPeriod, at, quoteId) + enum class ParseFailure( val logValue: String, val shouldLogIncomingRejection: Boolean = true, @@ -138,13 +149,29 @@ data class PaykitPaymentRequest( fun isExpired(now: Instant): Boolean = isProposalExpired(now) || isPaymentDeadlineExpired(now) - fun acceptsLightningInvoiceAmountMsats(amountMsats: ULong?): Boolean = - amountMsats == null || amountMsats == satsToMsat(amountSats) + fun acceptsLightningInvoiceAmountMsats( + amountMsats: ULong?, + paymentTerms: PaykitRequestPayment? = null, + at: Instant = Clock.System.now(), + ): Boolean { + if (amountMsats == null) return true + val payment = runCatching { payment(PaykitAsset.BTC, at, paymentTerms?.quoteId) }.getOrNull() ?: return false + return payment.isValid(at) && (paymentTerms == null || paymentTerms == payment) && + payment.amount.atomic <= ULong.MAX_VALUE / 1000uL && amountMsats == satsToMsat(payment.amount.atomic) + } fun acceptsLightningInvoiceAmountSats(amountSats: ULong): Boolean = amountSats == 0uL || acceptsPaymentAmount(amountSats) - fun acceptsPaymentAmount(amountSats: ULong): Boolean = amountSats == this.amountSats + fun acceptsPaymentAmount( + amountSats: ULong, + paymentTerms: PaykitRequestPayment? = null, + at: Instant = Clock.System.now(), + ): Boolean { + val payment = runCatching { payment(PaykitAsset.BTC, at, paymentTerms?.quoteId) }.getOrNull() ?: return false + return payment.isValid(at) && (paymentTerms == null || paymentTerms == payment) && + amountSats == payment.amount.atomic + } fun belongsTo(subscription: PaykitSubscription): Boolean = billingPeriod != null && @@ -204,7 +231,7 @@ private fun String.redactedForPaymentRequestDiagnostics(): String = private data class ParsedPaykitPaymentRequestTerms( val terms: PaymentRequestTerms, - val amountSats: ULong, + val amount: PaykitAmount, val endpoints: List, val expiresAt: Instant?, val paymentDeadlineAt: Instant?, @@ -219,9 +246,10 @@ data class PaykitPaymentRequestTarget( ) data class PaykitPaymentRequestDraft( - val amountSats: ULong, + val amount: PaykitAmount, val note: String, val expiresAt: Instant, + val acceptedPaymentEndpointIdentifiers: List? = null, ) data class PaykitPaymentRequestCreation( @@ -231,7 +259,7 @@ data class PaykitPaymentRequestCreation( ) class PaykitSubscriptionDraft( - val amountSats: ULong, + val amount: PaykitAmount, val name: String, val description: String, val frequency: PaykitRecurrenceUnit, @@ -284,9 +312,12 @@ class PaykitPaymentRequestRepo @Inject constructor( private val diagnostics: PaykitPaymentRequestDiagnostics, private val paymentProofStore: PaykitPaymentProofStore, private val paymentProofRepo: PaykitPaymentProofRepo, + private val usdtPayments: PaykitUsdtPaymentRepo, private val subscriptionNotificationScheduler: PaykitSubscriptionNotificationScheduler, private val clock: Clock, @SubscriptionClock private val subscriptionClock: Clock, + private val lightningRepo: LightningRepo, + private val currencyRepo: CurrencyRepo, ) { companion object { private const val TAG = "PaykitPaymentRequestRepo" @@ -301,6 +332,7 @@ class PaykitPaymentRequestRepo @Inject constructor( private val creationMutex = Mutex() private val processingLock = Any() private val processingRequestIds = mutableSetOf() + private val processingSubscriptionIds = mutableSetOf() private val stateGeneration = AtomicLong() private val completedRefreshVersion = AtomicLong() private var completedRefreshGeneration = -1L @@ -684,7 +716,7 @@ class PaykitPaymentRequestRepo @Inject constructor( val generation = stateGeneration.get() val expectedIdentity = activeIdentity ?: throw PaykitPaymentRequestError.RequestUnavailable val proposalDate = clock.now() - if (draft.amountSats == 0uL || !isAvailable()) throw PaykitPaymentRequestError.RequestUnavailable + if (draft.amount.atomic == 0uL || !isAvailable()) throw PaykitPaymentRequestError.RequestUnavailable if (draft.expiresAt <= proposalDate) throw PaykitPaymentRequestError.RequestExpired val selectedSavedKey = savedPublicKeys.firstOrNull { @@ -696,16 +728,16 @@ class PaykitPaymentRequestRepo @Inject constructor( if (target !in targets) throw PaykitPaymentRequestError.RequestUnavailable val settings = settingsStore.data.first() if (!settings.sharesPrivatePaykitEndpoints) throw PaykitPaymentRequestError.RequestUnavailable - val endpointIdentifiers = acceptedPaymentEndpointIdentifiers(settings) + val endpointIdentifiers = acceptedPaymentEndpointIdentifiers(settings).filter { + draft.acceptedPaymentEndpointIdentifiers?.contains(it) != false + } if (endpointIdentifiers.isEmpty()) throw PaykitPaymentRequestError.RequestUnavailable val note = draft.note.trim().take(256) - val proposal = PaykitPaymentRequestProposalTerms( - amountValue = draft.amountSats.toBitcoinAmount(), - paymentReference = "bitkit-${UUID.randomUUID()}", - proposalExpiresAt = draft.expiresAt.toString(), - acceptedPaymentEndpointIdentifiers = endpointIdentifiers, - metadataJson = JsonObject(mapOf("note" to JsonPrimitive(note))).toString(), + val proposal = buildPaymentRequestProposal( + draft.copy(note = note), + endpointIdentifiers, + proposalDate ) actionVersion++ val record = paykitSdkService.proposePaymentRequest( @@ -733,6 +765,29 @@ class PaykitPaymentRequestRepo @Inject constructor( } } + private fun buildPaymentRequestProposal( + draft: PaykitPaymentRequestDraft, + endpointIdentifiers: List, + proposalDate: Instant, + ): PaykitPaymentRequestProposalTerms { + val rates = PaykitRequestPricing.rates( + draft.amount.asset, + endpointIdentifiers, + currencyRepo.currencyState.value.paykitRate, + proposalDate + ) + return PaykitPaymentRequestProposalTerms( + amountValue = draft.amount.value, + amountAsset = draft.amount.asset.code, + conversion = rates.takeIf { it.isNotEmpty() }?.let(PaymentConversion::Fixed), + paymentDeadline = PaymentDeadline.At(draft.expiresAt.toString()), + paymentReference = "bitkit-${UUID.randomUUID()}", + proposalExpiresAt = draft.expiresAt.toString(), + acceptedPaymentEndpointIdentifiers = endpointIdentifiers, + metadataJson = JsonObject(mapOf("note" to JsonPrimitive(draft.note))).toString(), + ) + } + suspend fun proposeSubscription( draft: PaykitSubscriptionDraft, target: PaykitPaymentRequestTarget, @@ -766,7 +821,7 @@ class PaykitPaymentRequestRepo @Inject constructor( val description = draft.description.trim() validateSubscriptionDraft(draft, name, validationDate) - val endpoints = subscriptionProposalEndpoints(target, savedPublicKeys, expectedIdentity) + val endpoints = subscriptionProposalEndpoints(draft.amount.asset, target, savedPublicKeys, expectedIdentity) val reservedIconUri = PaykitSubscriptionProposal.reservedIconUri.takeIf { draft.iconBytes != null } val preflight = buildSubscriptionProposal(draft, name, description, reservedIconUri, endpoints, clock.now()) PaykitSubscriptionProposal.validate(preflight) @@ -804,7 +859,7 @@ class PaykitPaymentRequestRepo @Inject constructor( name: String, proposalDate: Instant, ) { - val hasValidContent = draft.amountSats != 0uL && name.isNotEmpty() + val hasValidContent = draft.amount.atomic != 0uL && name.isNotEmpty() val canPropose = draft.frequency.isSupported && isAvailable() if (!hasValidContent || !canPropose) { throw PaykitPaymentRequestError.RequestUnavailable @@ -817,6 +872,7 @@ class PaykitPaymentRequestRepo @Inject constructor( } private suspend fun subscriptionProposalEndpoints( + asset: PaykitAsset, target: PaykitPaymentRequestTarget, savedPublicKeys: List, expectedIdentity: String, @@ -829,7 +885,7 @@ class PaykitPaymentRequestRepo @Inject constructor( } .orEmpty() val settings = settingsStore.data.first() - val endpoints = acceptedPaymentEndpointIdentifiers(settings) + val endpoints = PaykitRequestPricing.subscriptionEndpoints(asset, acceptedPaymentEndpointIdentifiers(settings)) if (target !in targets || !settings.sharesPrivatePaykitEndpoints || endpoints.isEmpty()) { throw PaykitPaymentRequestError.RequestUnavailable } @@ -850,9 +906,12 @@ class PaykitPaymentRequestRepo @Inject constructor( "benefits" to JsonArray(emptyList()), ) iconUri?.let { subscriptionMetadata["icon_uri"] = JsonPrimitive(it) } + val rates = PaykitRequestPricing.rates(draft.amount.asset, endpointIdentifiers, null, startsAt) val timestamp = Instant.fromEpochSeconds(startsAt.epochSeconds).toString() return PaykitPaymentRequestProposalTerms( - amountValue = draft.amountSats.toBitcoinAmount(), + amountValue = draft.amount.value, + amountAsset = draft.amount.asset.code, + conversion = rates.takeIf { it.isNotEmpty() }?.let(PaymentConversion::Fixed), paymentReference = "bitkit-${UUID.randomUUID()}", proposalExpiresAt = draft.expiresAt.toString(), acceptedPaymentEndpointIdentifiers = endpointIdentifiers, @@ -1100,7 +1159,11 @@ class PaykitPaymentRequestRepo @Inject constructor( identity = identity, subscriptionId = it.id, ).getOrThrow() - if (protectedRequestIds.isNotEmpty()) { + val protectedUsdtRequestIds = usdtPayments.protectedRequestIdsForSubscriptionCancellation( + identity = identity, + subscriptionId = it.id, + ).getOrThrow() + if (protectedRequestIds.isNotEmpty() || protectedUsdtRequestIds.isNotEmpty()) { throw PaykitPaymentRequestError.OperationInProgress } } @@ -1194,7 +1257,8 @@ class PaykitPaymentRequestRepo @Inject constructor( val reopenableHardwareProofs = expectedIdentity?.let { identity -> paymentProofStore.load().filter { it.isReopenableHardwareReceipt(identity) } }.orEmpty() - val allSubscriptions = records.mapNotNull(PaymentRequestRecord::toPaykitSubscription) + val receipts = expectedIdentity?.let { usdtPayments.verifiedReceipts(it).getOrThrow() }.orEmpty() + val allSubscriptions = records.mapNotNull { it.toPaykitSubscription(verifiedUsdtReceipts = receipts) } .map { it.withExpiredLifecycle(subscriptionNow) } val blockedSubscriptionIds = allSubscriptions.mapNotNull { subscription -> subscription.id.takeIf { @@ -1237,7 +1301,7 @@ class PaykitPaymentRequestRepo @Inject constructor( .mapTo(mutableSetOf()) { it.id } val updatedDismissedPaymentIds = dismissedSubscriptionPaymentIds.intersect(activeRecurringRequestIds) val dueRequests = recurringRequestsBySubscription - .filterKeys { it.lifecycleState == PaymentRequestLifecycleState.ACTIVE_RECURRING && !it.hasPaymentDeadline } + .filterKeys { it.lifecycleState == PaymentRequestLifecycleState.ACTIVE_RECURRING } .values .flatten() .filter { @@ -1416,8 +1480,13 @@ class PaykitPaymentRequestRepo @Inject constructor( }.awaitAll() } - private fun acceptedPaymentEndpointIdentifiers(settings: SettingsData): List = buildList { - if (PublicPaykitRepo.isLightningPaymentOptionEnabled(settings)) add(MethodId.Bolt11.rawValue) + fun acceptedPaymentEndpointIdentifiers(settings: SettingsData): List = buildList { + if (PublicPaykitRepo.isUsdtPaymentOptionEnabled(settings)) add(MethodId.UsdtArbitrum.rawValue) + if (lightningRepo.canReceive() && PublicPaykitRepo.isLightningPaymentOptionEnabled(settings)) { + add( + MethodId.Bolt11.rawValue + ) + } if (PublicPaykitRepo.isOnchainPaymentOptionEnabled(settings)) { addAll(MethodId.entries.filter { it.isOnchain }.map(MethodId::rawValue)) } @@ -1434,6 +1503,12 @@ class PaykitPaymentRequestRepo @Inject constructor( activatedGeneration == stateGeneration.get() && request.id in acceptedOneTimeRequestIds private fun hasCurrentExecutionContext(request: PaykitPaymentRequest): Boolean { + if (synchronized(processingLock) { + PaykitSubscriptionId(request.paymentRequestId, request.counterparty) in processingSubscriptionIds + } + ) { + return false + } if (request.billingPeriod == null) { return hasLocalAcceptance(request) && _paymentRequestHistory.value.any { it.id == request.id && it.lifecycleState == PaymentRequestLifecycleState.ACCEPTED @@ -1506,15 +1581,21 @@ class PaykitPaymentRequestRepo @Inject constructor( operation: suspend (PaykitSubscription) -> PaymentRequestRecord, ): Result = withContext(ioDispatcher) { runSuspendCatching { - operationMutex.withLock { - val current = _subscriptions.value.firstOrNull { it.id == subscription.id } - ?: throw PaykitPaymentRequestError.RequestUnavailable - actionVersion++ - val record = operation(current) - processPendingMessages() - val identity = activeIdentity ?: throw PaykitPaymentRequestError.RequestUnavailable - applySubscriptionRecordLocked(record, subscriptionClock.now()) - synchronizeAfterSubscriptionAction(identity) + val isNewAction = synchronized(processingLock) { processingSubscriptionIds.add(subscription.id) } + if (!isNewAction) throw PaykitPaymentRequestError.OperationInProgress + try { + operationMutex.withLock { + val current = _subscriptions.value.firstOrNull { it.id == subscription.id } + ?: throw PaykitPaymentRequestError.RequestUnavailable + actionVersion++ + val record = operation(current) + processPendingMessages() + val identity = activeIdentity ?: throw PaykitPaymentRequestError.RequestUnavailable + applySubscriptionRecordLocked(record, subscriptionClock.now()) + synchronizeAfterSubscriptionAction(identity) + } + } finally { + synchronized(processingLock) { processingSubscriptionIds.remove(subscription.id) } } }.onFailure { Logger.warn("Failed to update Paykit subscription", it, context = TAG) } } @@ -1531,7 +1612,9 @@ class PaykitPaymentRequestRepo @Inject constructor( } private suspend fun applySubscriptionRecordLocked(record: PaymentRequestRecord, now: Instant) { - val subscription = record.toPaykitSubscription()?.withExpiredLifecycle(now) ?: return + val receipts = activeIdentity?.let { usdtPayments.verifiedReceipts(it).getOrThrow() }.orEmpty() + val subscription = record.toPaykitSubscription(verifiedUsdtReceipts = receipts) + ?.withExpiredLifecycle(now) ?: return _subscriptions.update { subscriptions -> subscriptions.filterNot { it.id == subscription.id } + subscription } @@ -1551,8 +1634,7 @@ class PaykitPaymentRequestRepo @Inject constructor( val recurringRequests = requestsThroughAcceptance(subscription, now) val unpaidRequests = if ( - subscription.lifecycleState == PaymentRequestLifecycleState.ACTIVE_RECURRING && - !subscription.hasPaymentDeadline + subscription.lifecycleState == PaymentRequestLifecycleState.ACTIVE_RECURRING ) { recurringRequests.filter { it.lifecycleState != PaymentRequestLifecycleState.PROOF_SUBMITTED } } else { @@ -1823,6 +1905,13 @@ private fun PaymentRequestRecord.parsePaykitPaymentRequest( if (requiresActionableRequest && paymentDeadlineAt?.let { now > it } == true) { return PaykitPaymentRequestParseResult.Rejected(PaykitPaymentRequest.ParseFailure.Expired) } + val asset = PaykitAsset.entries.firstOrNull { it.code == requestTerms.amount.asset } + ?: return PaykitPaymentRequestParseResult.Rejected(PaykitPaymentRequest.ParseFailure.UnsupportedAsset) + val amount = runCatching { PaykitAmount.parse(asset, requestTerms.amount.value) }.getOrNull() + ?: return PaykitPaymentRequestParseResult.Rejected(PaykitPaymentRequest.ParseFailure.InvalidAmount) + if (asset == PaykitAsset.BTC && amount.atomic > ULong.MAX_VALUE / 1000uL) { + return PaykitPaymentRequestParseResult.Rejected(PaykitPaymentRequest.ParseFailure.AmountOutOfRange) + } var endpoints = PaykitIssuerInterop.supportedEndpointIdentifiers( requestTerms.acceptedPaymentEndpointIdentifiers, network, @@ -1856,7 +1945,7 @@ private fun PaymentRequestRecord.parsePaykitPaymentRequest( return PaykitPaymentRequestParseResult.Rejected(PaykitPaymentRequest.ParseFailure.Expired) } - val parsedTerms = ParsedPaykitPaymentRequestTerms(requestTerms, amountSats, endpoints, expiresAt, paymentDeadlineAt) + val parsedTerms = ParsedPaykitPaymentRequestTerms(requestTerms, amount, endpoints, expiresAt, paymentDeadlineAt) return PaykitPaymentRequestParseResult.Parsed(toPaykitPaymentRequest(expectedRole, parsedTerms, now)) } @@ -1868,8 +1957,9 @@ private fun PaymentRequestRecord.toPaykitPaymentRequest( paymentRequestId = paymentRequestId, proposalStreamItemId = proposalStreamItemId, counterparty = counterparty, - amountValue = parsedTerms.terms.amount.value, - amountSats = parsedTerms.amountSats, + amount = parsedTerms.amount, + paymentReference = parsedTerms.terms.paymentReference.exportText(), + pricing = PaykitRequestPricing(parsedTerms.terms.conversion, parsedTerms.terms.paymentDeadline, conversionQuotes), note = parsedTerms.terms.metadata.note(), createdAt = lastEventAt?.let { runCatching { Instant.parse(it) }.getOrNull() }, expiresAt = parsedTerms.expiresAt, @@ -1901,7 +1991,7 @@ private fun PaymentRequestRecord.toPaykitPaymentRequest( }, ) -private fun PaymentRequestRecord.toPaykitPaymentRequestHistory(now: Instant): PaykitPaymentRequest? { +internal fun PaymentRequestRecord.toPaykitPaymentRequestHistory(now: Instant): PaykitPaymentRequest? { val role = localRole ?: return null if (role == PaymentRequestLocalRole.UNKNOWN) return null return when (val result = parsePaykitPaymentRequest(role, now, requiresActionableRequest = false)) { @@ -1920,8 +2010,10 @@ private fun PaymentRequestRecord.toCreatedPaykitPaymentRequest( return PaykitPaymentRequest( paymentRequestId = paymentRequestId, counterparty = target.publicKey, - amountValue = draft.amountSats.toBitcoinAmount(), - amountSats = draft.amountSats, + amount = draft.amount, + paymentReference = terms?.paymentReference?.exportText().orEmpty(), + pricing = PaykitRequestPricing(terms?.conversion, terms?.paymentDeadline, conversionQuotes), + paymentDeadlineAt = PaykitRequestPricing(deadline = terms?.paymentDeadline).paymentDeadline(null), note = draft.note.takeIf(String::isNotBlank), createdAt = lastEventAt?.let { runCatching { Instant.parse(it) }.getOrNull() } ?: createdAt, expiresAt = draft.expiresAt, @@ -1945,9 +2037,6 @@ internal fun PrivateJsonObject.note(): String? = runCatching { ?.takeIf(String::isNotEmpty) }.getOrNull() -private fun ULong.toBitcoinAmount(): String = - BigDecimal(toString()).movePointLeft(8).stripTrailingZeros().toPlainString() - internal fun String.toPaykitSats(): ULong? { if (!bitcoinAmountPattern.matches(this)) return null return runCatching { diff --git a/app/src/main/java/to/bitkit/repositories/PaykitSubscription.kt b/app/src/main/java/to/bitkit/repositories/PaykitSubscription.kt index 83a5d33b2b..cad7e3c783 100644 --- a/app/src/main/java/to/bitkit/repositories/PaykitSubscription.kt +++ b/app/src/main/java/to/bitkit/repositories/PaykitSubscription.kt @@ -15,6 +15,9 @@ import kotlinx.serialization.json.contentOrNull import kotlinx.serialization.json.jsonArray import kotlinx.serialization.json.jsonObject import kotlinx.serialization.json.jsonPrimitive +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset +import to.bitkit.models.PaykitRequestPricing import java.time.ZoneOffset import java.time.ZonedDateTime import kotlin.time.ExperimentalTime @@ -173,8 +176,9 @@ data class PaykitSubscriptionId( data class PaykitSubscription( val paymentRequestId: String, val counterparty: String, - val amountValue: String, - val amountSats: ULong, + val amount: PaykitAmount, + val paymentReference: String, + val pricing: PaykitRequestPricing, val note: String?, val createdAt: Instant?, val proposalExpiresAt: Instant?, @@ -186,9 +190,11 @@ data class PaykitSubscription( val lifecycleState: PaymentRequestLifecycleState, val paidPeriods: List, val paymentProofKinds: Map = emptyMap(), - val hasPaymentDeadline: Boolean = false, + val submittedPeriods: List = paidPeriods, val proposalStreamItemId: ULong? = null, ) { + val amountValue: String get() = amount.value + val id: PaykitSubscriptionId get() = PaykitSubscriptionId(paymentRequestId, counterparty) @@ -205,7 +211,6 @@ data class PaykitSubscription( fun isProposalActionable(now: Instant): Boolean = isProposalVisible(now) && - !hasPaymentDeadline && recurrence.unit.isSupported && recurrence.canMaterializePeriods && acceptedPaymentEndpointIdentifiers.isNotEmpty() @@ -244,8 +249,9 @@ data class PaykitSubscription( paymentRequestId = paymentRequestId, proposalStreamItemId = proposalStreamItemId, counterparty = counterparty, - amountValue = amountValue, - amountSats = amountSats, + amount = amount, + paymentReference = paymentReference, + pricing = pricing, note = note, createdAt = period.startsAt, expiresAt = null, @@ -256,6 +262,7 @@ data class PaykitSubscription( PaymentRequestLifecycleState.ACTIVE_RECURRING }, billingPeriod = period, + paymentDeadlineAt = pricing.paymentDeadline(period), paymentProofKind = paymentProofKinds[period], ) } @@ -263,17 +270,18 @@ data class PaykitSubscription( /** [now] is the subscription clock; [acceptedAt] is when accepting will store the acceptance, in real time. */ fun paymentDueOnAcceptance(now: Instant, acceptedAt: Instant = now): PaykitPaymentRequest? = - if (hasPaymentDeadline) null else requestsThrough(now, acceptedAt).firstOrNull() + requestsThrough(now, acceptedAt).firstOrNull() fun receivedPaymentRequests(): List { if (!isCreatedByUser) return emptyList() - return paidPeriods.map { period -> + return submittedPeriods.map { period -> PaykitPaymentRequest( paymentRequestId = paymentRequestId, proposalStreamItemId = proposalStreamItemId, counterparty = counterparty, - amountValue = amountValue, - amountSats = amountSats, + amount = amount, + paymentReference = paymentReference, + pricing = pricing, note = note, createdAt = period.startsAt, expiresAt = null, @@ -281,6 +289,7 @@ data class PaykitSubscription( direction = PaykitPaymentRequestDirection.Outgoing, lifecycleState = PaymentRequestLifecycleState.PROOF_SUBMITTED, billingPeriod = period, + paymentDeadlineAt = pricing.paymentDeadline(period), paymentProofKind = paymentProofKinds[period], ) } @@ -298,13 +307,13 @@ fun PaykitSubscription.runsUntilPaidThrough(now: Instant): Boolean = @Suppress("CyclomaticComplexMethod", "ReturnCount") internal fun PaymentRequestRecord.toPaykitSubscription( deliveryStatusOverride: PaykitPaymentRequestDeliveryStatus? = null, + verifiedUsdtReceipts: List = emptyList(), ): PaykitSubscription? { val role = localRole.toSubscriptionRole() ?: return null val requestTerms = terms ?: return null if (requestTerms.conversion != null) return null val sdkRecurrence = requestTerms.recurrence ?: return null if ( - requestTerms.amount.asset != "btc" || sdkRecurrence.every == 0u || sdkRecurrence.every > Int.MAX_VALUE.toUInt() ) { @@ -318,9 +327,10 @@ internal fun PaymentRequestRecord.toPaykitSubscription( val proposalExpiresAt = requestTerms.proposalExpiresAt?.parseInstant() ?: if (requestTerms.proposalExpiresAt == null) null else return null if (recurrenceEndsAt != null && recurrenceEndsAt <= startsAt) return null - val amountSats = requestTerms.amount.value.toPaykitSats() - ?.takeIf { it <= ULong.MAX_VALUE / 1000uL } - ?: return null + val asset = PaykitAsset.entries.firstOrNull { it.code == requestTerms.amount.asset } ?: return null + val amount = runCatching { PaykitAmount.parse(asset, requestTerms.amount.value) }.getOrNull() ?: return null + if (asset == PaykitAsset.BTC && amount.atomic > ULong.MAX_VALUE / 1000uL) return null + val endpoints = requestTerms.acceptedPaymentEndpointIdentifiers .filter { MethodId.fromRawValue(it) != null } .distinct() @@ -337,8 +347,9 @@ internal fun PaymentRequestRecord.toPaykitSubscription( paymentRequestId = paymentRequestId, proposalStreamItemId = proposalStreamItemId, counterparty = counterparty, - amountValue = requestTerms.amount.value, - amountSats = amountSats, + amount = amount, + paymentReference = requestTerms.paymentReference.exportText(), + pricing = PaykitRequestPricing(requestTerms.conversion, requestTerms.paymentDeadline, conversionQuotes), note = requestTerms.metadata.note()?.take(256), createdAt = lastEventAt?.parseInstant(), proposalExpiresAt = proposalExpiresAt, @@ -348,12 +359,26 @@ internal fun PaymentRequestRecord.toPaykitSubscription( role = role, deliveryStatus = subscriptionDeliveryStatus(role, deliveryStatusOverride), lifecycleState = state, - paidPeriods = payments.map { it.first }.distinct(), + paidPeriods = paidSubscriptionPeriods(payments, role, verifiedUsdtReceipts), + submittedPeriods = payments.map { it.first }.distinct(), paymentProofKinds = payments.mapNotNull { (period, kind) -> kind?.let { period to it } }.toMap(), - hasPaymentDeadline = requestTerms.paymentDeadline != null, + ) } +private fun PaymentRequestRecord.paidSubscriptionPeriods( + payments: List>, + role: PaykitSubscriptionRole, + receipts: List, +): List = payments.filter { (period, kind) -> + role == PaykitSubscriptionRole.Payer || kind != PaykitPaymentProofKind.Usdt || + receipts.any { receipt -> + receipt.satisfied && receipt.requestId == PaykitPaymentRequestId( + paymentRequestId, counterparty, period.startsAt.toString(), + ) && paymentProofs.any { it.eventId == receipt.proofEventId } + } +}.map { it.first }.distinct() + @Suppress("ReturnCount") private fun PaymentProofRecord.toSubscriptionPayment( recurrence: PaykitSubscriptionRecurrence, diff --git a/app/src/main/java/to/bitkit/repositories/PaykitSubscriptionNotificationScheduler.kt b/app/src/main/java/to/bitkit/repositories/PaykitSubscriptionNotificationScheduler.kt index ee990ca5dc..d172709a73 100644 --- a/app/src/main/java/to/bitkit/repositories/PaykitSubscriptionNotificationScheduler.kt +++ b/app/src/main/java/to/bitkit/repositories/PaykitSubscriptionNotificationScheduler.kt @@ -88,7 +88,6 @@ class PaykitSubscriptionNotificationScheduler @Inject constructor( val scheduledWork = subscriptions .filter { it.isPayer && - !it.hasPaymentDeadline && it.recurrence.unit.isSupported && acceptedAt(it) != null } diff --git a/app/src/main/java/to/bitkit/repositories/PaykitSubscriptionProposal.kt b/app/src/main/java/to/bitkit/repositories/PaykitSubscriptionProposal.kt index f22fa3ed14..27bf2d377b 100644 --- a/app/src/main/java/to/bitkit/repositories/PaykitSubscriptionProposal.kt +++ b/app/src/main/java/to/bitkit/repositories/PaykitSubscriptionProposal.kt @@ -1,23 +1,24 @@ package to.bitkit.repositories +import com.synonym.paykit.PaymentConversion +import com.synonym.paykit.PaymentDeadline import kotlinx.serialization.json.Json import kotlinx.serialization.json.JsonNull +import kotlinx.serialization.json.JsonObjectBuilder import kotlinx.serialization.json.JsonPrimitive import kotlinx.serialization.json.buildJsonObject import kotlinx.serialization.json.put import kotlinx.serialization.json.putJsonArray import kotlinx.serialization.json.putJsonObject import to.bitkit.services.PaykitPaymentRequestProposalTerms +import to.bitkit.services.PaykitSdkService internal object PaykitSubscriptionProposal { - /** Maximum plaintext size accepted by Paykit's pubky-noise transport. */ - const val MAX_MESSAGE_BYTES = 1000 - /** Longest JPEG avatar URI produced by Bitkit's staging profile namespace. */ val reservedIconUri = "pubky://" + "x".repeat(122) fun validate(terms: PaykitPaymentRequestProposalTerms) { - if (encodedSize(terms) > MAX_MESSAGE_BYTES) throw PaykitPaymentRequestError.SubscriptionTooLong + if (encodedSize(terms) > PaykitSdkService.MAX_MESSAGE_BYTES) throw PaykitPaymentRequestError.SubscriptionTooLong } fun encodedSize(terms: PaykitPaymentRequestProposalTerms): Int { @@ -32,7 +33,7 @@ internal object PaykitSubscriptionProposal { putJsonObject("request") { putJsonObject("amount") { put("value", terms.amountValue) - put("asset", "btc") + put("asset", terms.amountAsset) } put("payment_reference", terms.paymentReference) put("proposal_expires_at", terms.proposalExpiresAt) @@ -47,9 +48,46 @@ internal object PaykitSubscriptionProposal { terms.acceptedPaymentEndpointIdentifiers.forEach { add(JsonPrimitive(it)) } } put("required_app_id", "bitkit") + putConversion(terms.conversion) + terms.paymentDeadline?.let { deadline -> + putJsonObject("payment_deadline") { + when (deadline) { + is PaymentDeadline.At -> { + put("type", "at") + put("timestamp", deadline.timestamp) + } + is PaymentDeadline.PeriodStart -> { + put("type", "period_start") + put("seconds", Json.parseToJsonElement(deadline.seconds.toString())) + } + } + } + } put("metadata", Json.parseToJsonElement(terms.metadataJson)) } } return wire.toString().encodeToByteArray().size } + private fun JsonObjectBuilder.putConversion(conversion: PaymentConversion?) { + conversion?.let { conversion -> + putJsonObject("conversion") { + when (conversion) { + is PaymentConversion.Fixed -> { + put("type", "fixed") + putJsonArray("rates") { + conversion.rates.forEach { rate -> + add( + buildJsonObject { + put("asset", rate.asset) + put("value", rate.value) + } + ) + } + } + } + PaymentConversion.PerPeriod -> put("type", "per_period") + } + } + } + } } diff --git a/app/src/main/java/to/bitkit/repositories/PaykitUsdtPaymentRepo.kt b/app/src/main/java/to/bitkit/repositories/PaykitUsdtPaymentRepo.kt new file mode 100644 index 0000000000..a209b71ad3 --- /dev/null +++ b/app/src/main/java/to/bitkit/repositories/PaykitUsdtPaymentRepo.kt @@ -0,0 +1,589 @@ +@file:OptIn(kotlin.time.ExperimentalTime::class) + +package to.bitkit.repositories + +import com.synonym.bitkitcore.UsdtDestination +import com.synonym.bitkitcore.UsdtException +import com.synonym.bitkitcore.UsdtPaymentProof +import com.synonym.bitkitcore.UsdtPaymentProofBinding +import com.synonym.bitkitcore.UsdtQuote +import com.synonym.bitkitcore.UsdtTransfer +import com.synonym.bitkitcore.UsdtTransferStatus +import com.synonym.paykit.BillingPeriod +import com.synonym.paykit.PaykitPublicKeys +import com.synonym.paykit.PaymentProofRecord +import com.synonym.paykit.PaymentRequestLocalRole +import com.synonym.paykit.PaymentRequestRecord +import com.synonym.paykit.PubkyIdentityCapability +import kotlinx.coroutines.CoroutineDispatcher +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.update +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock +import kotlinx.coroutines.withContext +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable +import kotlinx.serialization.encodeToString +import kotlinx.serialization.json.Json +import kotlinx.serialization.json.JsonNull +import kotlinx.serialization.json.buildJsonObject +import kotlinx.serialization.json.put +import to.bitkit.data.keychain.Keychain +import to.bitkit.di.IoDispatcher +import to.bitkit.ext.runSuspendCatching +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset +import to.bitkit.models.PaykitRequestPayment +import to.bitkit.models.PaykitUsdt +import to.bitkit.models.PaykitUsdtStateBackup +import to.bitkit.models.PubkyPublicKeyFormat +import to.bitkit.services.PaykitSdkService +import to.bitkit.viewmodels.ContactPaymentContext +import java.util.UUID +import javax.inject.Inject +import javax.inject.Singleton +import kotlin.time.Clock +import kotlin.time.Instant + +@Serializable +data class PaykitUsdtProof( + val type: String, + @SerialName("chain_id") val chainId: String, + @SerialName("transaction_hash") val transactionHash: String, + @SerialName("receipt_log_index") val receiptLogIndex: String, + val signature: String, +) { + constructor(value: UsdtPaymentProof) : this( + "erc20-transfer-eip712", + value.chainId, + value.transactionHash, + value.receiptLogIndex, + value.signature + ) + val coreValue: UsdtPaymentProof get() = UsdtPaymentProof(chainId, transactionHash, receiptLogIndex, signature) +} + +@Serializable +data class PaykitUsdtAttempt( + val quoteId: String, + val wallet: String, + val identity: String, + val contact: String, + val requestId: PaykitPaymentRequestId?, + val binding: UsdtPaymentProofBinding?, + val billingPeriod: PaykitBillingPeriod?, + val proof: PaykitUsdtProof? = null, + val proofQueued: Boolean = false, + val paymentStarted: Boolean = false, +) + +@Serializable +data class PaykitUsdtReceipt( + val wallet: String, + val identity: String, + val requestId: PaykitPaymentRequestId, + val paymentId: String, + val proofEventId: String, + val verified: Boolean, + val transferId: String, + val amount: PaykitAmount, + val receivedAtMillis: Long, + val underpaid: Boolean, + val afterExpiry: Boolean, +) { + val satisfied: Boolean get() = verified && !underpaid && !afterExpiry +} + +@Singleton +class PaykitUsdtPaymentRepo @Inject constructor( + @IoDispatcher private val ioDispatcher: CoroutineDispatcher, + private val keychain: Keychain, + private val sdk: PaykitSdkService, + private val proofs: PaykitPaymentProofRepo, + private val usdt: UsdtRepo, + private val clock: Clock, +) { + companion object { + private val KEY = Keychain.Key.PAYKIT_USDT_PAYMENTS.name + + fun binding( + request: PaykitPaymentRequest, + identity: String, + paymentAppId: String, + quoteId: String?, + period: BillingPeriod?, + ): UsdtPaymentProofBinding { + val local = PaykitPublicKeys.raw(identity) + val remote = PaykitPublicKeys.raw(request.counterparty) + val incoming = request.direction == PaykitPaymentRequestDirection.Incoming + return UsdtPaymentProofBinding( + payer = if (incoming) local else remote, + payee = if (incoming) remote else local, + paymentAppId = paymentAppId, + paymentRequestId = UUID.fromString(request.paymentRequestId).toString(), + paymentReference = request.paymentReference, + paymentEndpointIdentifier = MethodId.UsdtArbitrum.rawValue, + // EIP-712 binds the proof's timestamp strings, not their normalized spelling. + periodStartsAt = period?.startsAt.orEmpty(), + periodEndsAt = period?.endsAt.orEmpty(), + conversionQuoteId = quoteId.orEmpty(), + ) + } + + fun validateProofSize(binding: UsdtPaymentProofBinding) { + val profile = + PaykitUsdtProof( + UsdtPaymentProof("42161", "0x" + "0".repeat(64), "9".repeat(78), "0x" + "0".repeat(130)) + ) + val message = buildJsonObject { + put("version", 1) + put("kind", "paykit.payment_proof") + put("app_id", "bitkit") + put("event_id", UUID.randomUUID().toString()) + put("payment_request_id", binding.paymentRequestId) + put("payment_reference", binding.paymentReference) + put("payment_app_id", binding.paymentAppId) + put("payment_endpoint_identifier", binding.paymentEndpointIdentifier) + put( + "billing_period", + if (binding.periodStartsAt.isEmpty()) { + JsonNull + } else { + buildJsonObject { + put("starts_at", binding.periodStartsAt) + put("ends_at", binding.periodEndsAt) + } + } + ) + if (binding.conversionQuoteId.isNotEmpty()) put("conversion_quote_id", binding.conversionQuoteId) + put("proof", Json.encodeToJsonElement(PaykitUsdtProof.serializer(), profile)) + } + if (message.toString().toByteArray(Charsets.UTF_8).size > PaykitSdkService.MAX_MESSAGE_BYTES) { + throw PaykitPaymentRequestError.RequestUnavailable + } + } + } + + @Serializable + private data class State( + val attempts: List = emptyList(), + val receipts: List = emptyList(), + ) + + private var activeWallet: String? = null + private var activeIdentity: String? = null + private val mutex = Mutex() + private val _attempts = MutableStateFlow>(emptyList()) + val attempts = _attempts.asStateFlow() + private val _receipts = MutableStateFlow>(emptyList()) + val receipts = _receipts.asStateFlow() + private val _resumableRequests = MutableStateFlow>(emptySet()) + val resumableRequests = _resumableRequests.asStateFlow() + + private val _backupStateVersion = MutableStateFlow(0L) + val backupStateVersion = _backupStateVersion.asStateFlow() + + suspend fun backupSnapshot(): PaykitUsdtStateBackup = withContext(ioDispatcher) { + val state = load() + PaykitUsdtStateBackup(state.attempts, state.receipts.map { PaykitUsdtStateBackup.Receipt(it) }) + } + + suspend fun restoreBackup(backup: PaykitUsdtStateBackup) = withContext(ioDispatcher) { + mutex.withLock { + val state = load() + val attempts = state.attempts.associateBy { it.wallet to it.quoteId }.toMutableMap() + for (restored in backup.attempts) { + val key = restored.wallet to restored.quoteId + val local = attempts[key] + attempts[key] = local?.copy( + paymentStarted = local.paymentStarted || restored.paymentStarted, + proof = local.proof ?: restored.proof, + ) ?: restored + } + save( + State( + attempts = attempts.values.map { it.copy(proofQueued = false) }, + receipts = (state.receipts + backup.receipts.map { it.restored() }) + .distinctBy { it.wallet to it.paymentId }, + ) + ) + } + } + + suspend fun send(quote: UsdtQuote, beforeSend: suspend () -> Unit = {}): Result = withContext(ioDispatcher) { + runSuspendCatching { + setPaymentStarted(quote.id, true).getOrThrow() + val result = runSuspendCatching { + beforeSend() + usdt.send(quote).getOrThrow() + } + if (result.isFailure) { + val history = storedTransfer(quote.id) + if (history.isSuccess && history.getOrNull() == null) setPaymentStarted(quote.id, false) + } + result.getOrThrow() + Unit + } + } + + private suspend fun setPaymentStarted(quoteId: String, started: Boolean): Result = withContext(ioDispatcher) { + runSuspendCatching { + mutex.withLock { + val state = load() + val attempt = state.attempts.singleOrNull { + it.quoteId == quoteId && it.wallet == activeWallet && it.identity == activeIdentity + } ?: throw PaykitPaymentRequestError.RequestUnavailable + save( + state.copy( + attempts = state.attempts.map { + if (it == attempt) it.copy(paymentStarted = started) else it + } + ) + ) + if (started) _resumableRequests.update { it - setOfNotNull(attempt.requestId) } + } + } + } + + private fun load(): State = keychain.loadString(KEY)?.let { Json.decodeFromString(it) } ?: State() + + private suspend fun save(state: State) { + keychain.upsertString(KEY, Json.encodeToString(state)) + publish(state) + _backupStateVersion.update { it + 1 } + } + + private fun publish(state: State) { + _attempts.update { state.attempts.filter { it.wallet == activeWallet && it.identity == activeIdentity } } + _receipts.update { state.receipts.filter { it.wallet == activeWallet && it.identity == activeIdentity } } + } + + suspend fun protectedRequestIdsForSubscriptionCancellation( + identity: String, + subscriptionId: PaykitSubscriptionId, + ): Result> = withContext(ioDispatcher) { + runSuspendCatching { + mutex.withLock { + val state = load() + val matching = state.attempts.filter { + PubkyPublicKeyFormat.matches(it.identity, identity) && + it.requestId?.paymentRequestId == subscriptionId.paymentRequestId && + PubkyPublicKeyFormat.matches(it.requestId.counterparty, subscriptionId.counterparty) && + !it.proofQueued + } + if (matching.isEmpty()) return@withLock emptySet() + val owner = usdt.paymentEndpoint().getOrThrow().value.lowercase() + matching.filter { it.wallet == owner }.mapNotNull { attempt -> + val transfer = storedTransfer(attempt.quoteId).getOrThrow() + val terminalFailure = transfer?.status in setOf( + UsdtTransferStatus.FAILED, UsdtTransferStatus.REPLACED, + ) + attempt.requestId.takeIf { + !terminalFailure && (attempt.paymentStarted || attempt.proof != null || transfer != null) + } + }.toSet() + } + } + } + + suspend fun verifiedReceipts(identity: String): Result> = withContext(ioDispatcher) { + runSuspendCatching { + mutex.withLock { + val matching = load().receipts.filter { + PubkyPublicKeyFormat.matches(it.identity, identity) && it.satisfied + } + if (matching.isEmpty()) return@withLock emptyList() + val owner = usdt.paymentEndpoint().getOrThrow().value.lowercase() + matching.filter { it.wallet == owner } + } + } + } + + fun hasBinding(requestId: PaykitPaymentRequestId): Boolean = _attempts.value.any { it.requestId == requestId } + + fun contact(transferId: String): String? = _attempts.value.firstOrNull { it.quoteId == transferId }?.contact + ?: _receipts.value.firstOrNull { it.transferId == transferId }?.requestId?.counterparty + + suspend fun prepare( + context: ContactPaymentContext, + quote: UsdtQuote, + amount: PaykitAmount?, + paymentTerms: PaykitRequestPayment?, + ) = + withContext(ioDispatcher) { + runSuspendCatching { + mutex.withLock { + val identity = currentIdentity() ?: throw PaykitPaymentRequestError.RequestUnavailable + validateQuote(context, quote, amount, paymentTerms) + val request = context.incomingPaymentRequest + val owner = usdt.paymentEndpoint().getOrThrow().value.lowercase() + activeWallet = owner + activeIdentity = identity + val state = load() + validateReplacement(state, owner, identity, request, quote.id) + val binding = request?.let { + binding( + it, + identity, + context.privatePaymentContext?.paymentAppsByEndpoint?.get(MethodId.UsdtArbitrum.rawValue) + ?: throw PaykitPaymentRequestError.RequestUnavailable, + paymentTerms?.quoteId, + it.billingPeriod?.sdkValue + ) + } + binding?.let(::validateProofSize) + val attempt = + PaykitUsdtAttempt( + quote.id, + owner, + identity, + context.publicKey, + request?.id, + binding, + request?.billingPeriod + ) + val existing = state.attempts.firstOrNull { it.wallet == owner && it.quoteId == quote.id } + val previousBinding = existing?.copy(proof = null, proofQueued = false, paymentStarted = false) + if (previousBinding != null && previousBinding != attempt) { + throw PaykitPaymentRequestError.OperationInProgress + } + save( + state.copy( + attempts = state.attempts.filterNot { + it.wallet == owner && it.identity == identity && + (it.quoteId == quote.id || (request != null && it.requestId == request.id)) + } + (existing ?: attempt) + ) + ) + } + } + } + + private fun validateQuote( + context: ContactPaymentContext, + quote: UsdtQuote, + amount: PaykitAmount?, + paymentTerms: PaykitRequestPayment?, + ) { + val recipient = context.endpoints.firstOrNull { it.methodId == MethodId.UsdtArbitrum } + ?.let { PaykitUsdt.address(it.rawPayload) } + if (recipient == null || quote.destination != UsdtDestination.ARBITRUM || + !quote.recipient.equals(recipient, true) + ) { + throw PaykitPaymentRequestError.RequestUnavailable + } + val payment = PaykitAmount(PaykitAsset.USDT, quote.amount) + if (payment != amount || quote.amount == 0uL) throw PaykitPaymentRequestError.RequestUnavailable + context.incomingPaymentRequest?.let { validateRequestTerms(it, payment, paymentTerms) } + } + + private fun validateRequestTerms( + request: PaykitPaymentRequest, + payment: PaykitAmount, + terms: PaykitRequestPayment?, + ) { + val now = clock.now() + val isAvailable = MethodId.UsdtArbitrum.rawValue in request.acceptedPaymentEndpointIdentifiers && + !request.isExpired(now) + if (!isAvailable || terms == null || !terms.isValid(now)) throw PaykitPaymentRequestError.RequestUnavailable + if (terms.amount != payment || request.payment(PaykitAsset.USDT, now, terms.quoteId) != terms) { + throw PaykitPaymentRequestError.RequestUnavailable + } + } + + private suspend fun validateReplacement( + state: State, + owner: String, + identity: String, + request: PaykitPaymentRequest?, + quoteId: String, + ) { + if (request == null) return + val previous = state.attempts.firstOrNull { + it.wallet == owner && it.identity == identity && it.requestId == request.id + }?.takeIf { it.quoteId != quoteId } ?: return + val transfer = storedTransfer(previous.quoteId).getOrThrow() + if (transfer.isUnresolved(previous.paymentStarted)) throw PaykitPaymentRequestError.OperationInProgress + } + + private fun UsdtTransfer?.isUnresolved(started: Boolean): Boolean = if (this == null) { + started + } else { + status !in setOf(UsdtTransferStatus.FAILED, UsdtTransferStatus.REPLACED) + } + + suspend fun reconcile() = withContext(ioDispatcher) { + runSuspendCatching { + mutex.withLock { + val identity = currentIdentity() ?: return@withLock + val owner = usdt.paymentEndpoint().getOrThrow().value.lowercase() + activeWallet = owner + activeIdentity = identity + val state = load() + publish(state) + reconcileAttempts(owner, identity, state) + reconcileReceipts(owner, identity) + } + } + } + + private suspend fun reconcileAttempts(owner: String, identity: String, state: State) { + val localAttempts = state.attempts.filter { it.wallet == owner && it.identity == identity } + val resumable = mutableSetOf() + for (attempt in localAttempts) { + val requestId = attempt.requestId ?: continue + val transfer = storedTransfer(attempt.quoteId).getOrThrow() + if (!transfer.isUnresolved(attempt.paymentStarted)) resumable += requestId + if (!attempt.proofQueued && (attempt.proof != null || transfer?.status == UsdtTransferStatus.CONFIRMED)) { + submitAttemptProof(attempt, requestId) + } + } + _resumableRequests.update { resumable } + } + + private suspend fun submitAttemptProof(attempt: PaykitUsdtAttempt, requestId: PaykitPaymentRequestId) { + val binding = attempt.binding ?: return + val proof = attempt.proof + ?: paymentProof(attempt.quoteId, binding).getOrThrow()?.let(::PaykitUsdtProof) + ?: return + if (attempt.proof == null) updateAttempt(attempt) { it.copy(proof = proof) } + val pending = PendingPaykitPaymentProof( + identity = attempt.identity, + requestId = requestId, + paymentAppId = binding.paymentAppId, + paymentEndpointIdentifier = binding.paymentEndpointIdentifier, + kind = PaykitPaymentProofKind.Usdt, + paymentIdentifier = attempt.quoteId, + proofData = Json.encodeToString(proof), + billingPeriod = attempt.billingPeriod, + conversionQuoteId = binding.conversionQuoteId.takeIf { it.isNotEmpty() }, + ) + if (proofs.submit(pending).getOrThrow()) updateAttempt(attempt) { it.copy(proofQueued = true) } + } + + private suspend fun updateAttempt(attempt: PaykitUsdtAttempt, update: (PaykitUsdtAttempt) -> PaykitUsdtAttempt) { + val current = load() + save( + current.copy( + attempts = current.attempts.map { + if ( + it.quoteId == attempt.quoteId && it.wallet == attempt.wallet && it.identity == attempt.identity + ) { + update( + it + ) + } else { + it + } + } + ) + ) + } + + private suspend fun reconcileReceipts(owner: String, identity: String) { + for (record in sdk.paymentRequests().filter { it.localRole == PaymentRequestLocalRole.PAYEE }) { + val submissions = record.paymentProofs.filter { + it.paymentEndpointIdentifier == MethodId.UsdtArbitrum.rawValue + } + for (submission in submissions) { + reconcileReceipt(record, submission, owner, identity) + } + } + } + + private fun receivedRequest(record: PaymentRequestRecord, submission: PaymentProofRecord): PaykitPaymentRequest? { + val period = submission.billingPeriod + val request = if (period != null) { + record.toPaykitSubscription()?.receivedPaymentRequests()?.firstOrNull { + it.billingPeriod?.startsAt == Instant.parse(period.startsAt) && + it.billingPeriod.endsAt == Instant.parse(period.endsAt) + } + } else { + record.toPaykitPaymentRequestHistory(clock.now()) + } + return request?.takeIf { submission.paymentEndpointIdentifier in it.acceptedPaymentEndpointIdentifiers } + } + + private fun submittedProof(submission: PaymentProofRecord): PaykitUsdtProof? = runCatching { + Json.decodeFromString(submission.proof.exportText()) + }.getOrNull()?.takeIf { it.type == "erc20-transfer-eip712" && submission.paymentAppId == "bitkit" } + + private suspend fun reconcileReceipt( + record: PaymentRequestRecord, + submission: PaymentProofRecord, + owner: String, + identity: String, + ) { + val request = receivedRequest(record, submission) ?: return + val proof = submittedProof(submission) ?: return + val binding = binding( + request, + identity, + submission.paymentAppId, + submission.conversionQuoteId, + submission.billingPeriod + ) + val paymentResult = verifyPayment(binding, proof.coreValue) + if (paymentResult.exceptionOrNull() is UsdtException.InvalidPaymentProof || + paymentResult.isSuccess && paymentResult.getOrNull() == null + ) { + invalidateReceipt(submission.eventId, request.id, owner, identity) + return + } + val payment = paymentResult.getOrThrow() ?: return + val current = load() + val samePayment = current.receipts.filter { it.wallet == owner && it.paymentId == payment.paymentId } + if (samePayment.any { it.identity != identity || it.requestId != request.id }) return + val receivedAt = Instant.fromEpochSeconds(payment.timestamp.toLong()) + val terms = runCatching { + request.payment( + PaykitAsset.USDT, + receivedAt, + submission.conversionQuoteId + ) + }.getOrNull() + if (terms != null) { + val amount = PaykitAmount(PaykitAsset.USDT, payment.amount) + val receipt = PaykitUsdtReceipt( + wallet = owner, + identity = identity, + requestId = request.id, + paymentId = payment.paymentId, + proofEventId = submission.eventId, + verified = true, + transferId = payment.transferId, + amount = amount, + receivedAtMillis = receivedAt.toEpochMilliseconds(), + underpaid = amount.atomic < terms.amount.atomic, + afterExpiry = !terms.isValid(receivedAt), + ) + save(current.copy(receipts = current.receipts - samePayment.toSet() + receipt)) + } + } + + private suspend fun invalidateReceipt( + proofEventId: String, + requestId: PaykitPaymentRequestId, + owner: String, + identity: String, + ) { + val current = load() + val matching = current.receipts.filter { + it.wallet == owner && it.identity == identity && it.requestId == requestId + }.filter { it.proofEventId == proofEventId && it.verified }.toSet() + if (matching.isEmpty()) return + save(current.copy(receipts = current.receipts.map { if (it in matching) it.copy(verified = false) else it })) + } + + private suspend fun paymentProof(quoteId: String, binding: UsdtPaymentProofBinding) = + usdt.operation { this.paymentProof(quoteId, binding) } + private suspend fun storedTransfer(id: String) = usdt.operation { wallet().history().firstOrNull { it.id == id } } + private suspend fun verifyPayment(binding: UsdtPaymentProofBinding, proof: UsdtPaymentProof) = + usdt.operation { wallet().verifyPaymentProof(binding, proof) } + + private suspend fun currentIdentity(): String? = sdk.identityStatus()?.takeIf { + it.capability == PubkyIdentityCapability.PRIVATE_LINK_CAPABLE + } + ?.publicKey?.let(PubkyPublicKeyFormat::normalized) +} diff --git a/app/src/main/java/to/bitkit/repositories/PrivatePaykitRepo.kt b/app/src/main/java/to/bitkit/repositories/PrivatePaykitRepo.kt index 5553481088..66e3ea5bc1 100644 --- a/app/src/main/java/to/bitkit/repositories/PrivatePaykitRepo.kt +++ b/app/src/main/java/to/bitkit/repositories/PrivatePaykitRepo.kt @@ -85,6 +85,7 @@ class PrivatePaykitRepo @Inject constructor( private val walletRepo: WalletRepo, private val publicPaykitRepo: PublicPaykitRepo, private val paymentRequestRepo: PaykitPaymentRequestRepo, + private val usdtRepo: UsdtRepo, private val coreService: CoreService, private val clock: Clock, ) { @@ -870,6 +871,7 @@ class PrivatePaykitRepo @Inject constructor( paymentListVersion = paymentListVersion, previousPaymentListVersion = consumedVersion.takeIf { paymentListVersion != null }, ), + endpoints = privatePayable, ) } @@ -1633,6 +1635,9 @@ class PrivatePaykitRepo @Inject constructor( runSuspendCatching { val settings = settingsStore.data.first() val endpoints = mutableListOf() + if (PublicPaykitRepo.isUsdtPaymentOptionEnabled(settings)) { + endpoints += usdtRepo.paymentEndpoint().getOrThrow() + } if (PublicPaykitRepo.isOnchainPaymentOptionEnabled(settings)) { val reservedAddress = addressReservationRepo.currentOrRotatedAddress( publicKey, diff --git a/app/src/main/java/to/bitkit/repositories/PublicPaykitRepo.kt b/app/src/main/java/to/bitkit/repositories/PublicPaykitRepo.kt index 2316dcecd4..3496b74c7d 100644 --- a/app/src/main/java/to/bitkit/repositories/PublicPaykitRepo.kt +++ b/app/src/main/java/to/bitkit/repositories/PublicPaykitRepo.kt @@ -16,6 +16,7 @@ import to.bitkit.di.IoDispatcher import to.bitkit.env.Env import to.bitkit.ext.runSuspendCatching import to.bitkit.ext.toHex +import to.bitkit.models.PaykitUsdt import to.bitkit.models.PubkyPublicKeyFormat import to.bitkit.models.toLdkNetwork import to.bitkit.services.CoreService @@ -46,6 +47,7 @@ sealed interface PublicPaykitPaymentResult { data class Opened( val paymentRequest: String, val privatePaymentContext: PrivatePaykitPaymentContext? = null, + val endpoints: List = emptyList(), ) : PublicPaykitPaymentResult data object NoEndpoint : PublicPaykitPaymentResult @@ -102,6 +104,7 @@ class PublicPaykitRepo @Inject constructor( private val paykitSdkService: PaykitSdkService, private val settingsStore: SettingsStore, private val clock: Clock, + private val usdtRepo: UsdtRepo, ) { companion object { private val methodIdPattern = Regex("^[a-z0-9]+-[a-z0-9]+-[a-z0-9]+$") @@ -113,6 +116,7 @@ class PublicPaykitRepo @Inject constructor( MethodId.P2wpkh, MethodId.P2sh, MethodId.P2pkh, + MethodId.UsdtArbitrum, ) private val publicBolt11Expiry = 24.hours @@ -127,6 +131,9 @@ class PublicPaykitRepo @Inject constructor( fun isOnchainPaymentOptionEnabled(settings: SettingsData): Boolean = settings.publicPaykitOnchainEnabled + fun isUsdtPaymentOptionEnabled(settings: SettingsData): Boolean = + Env.isUsdtEnabled && settings.publicPaykitUsdtEnabled + fun parseEndpoint( methodId: String, endpointData: String, @@ -135,6 +142,11 @@ class PublicPaykitRepo @Inject constructor( if (!methodIdPattern.matches(methodId)) return null val knownMethodId = MethodId.fromRawValue(methodId, network) ?: return null + if (knownMethodId == MethodId.UsdtArbitrum) { + return PaykitUsdt.address(endpointData)?.let { + Endpoint(methodId = knownMethodId, value = it, rawPayload = endpointData) + } + } val payload = PaykitIssuerInterop.parseEndpointPayload(endpointData) ?: return null return Endpoint( @@ -196,7 +208,7 @@ class PublicPaykitRepo @Inject constructor( val payable = endpoints.filter { isPayable(it) } if (payable.isEmpty()) return@runSuspendCatching PublicPaykitPaymentResult.NotOpened - PublicPaykitPaymentResult.Opened(paymentRequest(payable)) + PublicPaykitPaymentResult.Opened(paymentRequest(payable), endpoints = payable) } } @@ -357,6 +369,8 @@ class PublicPaykitRepo @Inject constructor( ) } + if (isUsdtPaymentOptionEnabled(settings)) endpoints += usdtRepo.paymentEndpoint().getOrThrow() + if (endpoints.isEmpty() && requireEndpoint) throw PublicPaykitError.NoSupportedEndpoint return endpoints @@ -433,6 +447,7 @@ class PublicPaykitRepo @Inject constructor( private suspend fun isPayable(endpoint: Endpoint): Boolean = runSuspendCatching { when (endpoint.methodId) { + MethodId.UsdtArbitrum -> Env.isUsdtEnabled && PaykitUsdt.address(endpoint.rawPayload) != null MethodId.Bolt11 -> { val scan = coreService.decode(endpoint.paymentRequest) as? Scanner.Lightning ?: return@runSuspendCatching false @@ -463,7 +478,7 @@ data class Endpoint( val appId: String? = null, ) { val paymentRequest: String - get() = value + get() = if (methodId == MethodId.UsdtArbitrum) PaykitUsdt.paymentUri(value) else value } enum class MethodId( @@ -472,6 +487,7 @@ enum class MethodId( val isOnchain: Boolean = false, val isBitkitManaged: Boolean = false, ) { + UsdtArbitrum(fixedRawValue = "usdt-arbitrum-address", isBitkitManaged = true), Bolt11(fixedRawValue = "btc-lightning-bolt11", isBitkitManaged = true), Lnurl(fixedRawValue = "btc-lightning-lnurl"), P2tr(onchainEndpoint = "p2tr", isOnchain = true, isBitkitManaged = true), diff --git a/app/src/main/java/to/bitkit/repositories/UsdtDepositRepo.kt b/app/src/main/java/to/bitkit/repositories/UsdtDepositRepo.kt new file mode 100644 index 0000000000..5371f1456b --- /dev/null +++ b/app/src/main/java/to/bitkit/repositories/UsdtDepositRepo.kt @@ -0,0 +1,17 @@ +package to.bitkit.repositories + +import com.synonym.bitkitcore.UsdtDepositNetwork +import kotlinx.collections.immutable.toImmutableList +import javax.inject.Inject +import javax.inject.Singleton + +@Singleton +class UsdtDepositRepo @Inject constructor(private val usdt: UsdtRepo) { + suspend fun depositNetworks() = usdt.operation { depositNetworks().toImmutableList() } + suspend fun prepareDeposit(network: UsdtDepositNetwork, amount: String) = + usdt.operation { prepareDeposit(network, amount) } + suspend fun depositHistory(offset: UInt) = usdt.operation { depositHistory(offset) } + suspend fun depositDetail(id: String, offset: UInt) = usdt.operation { depositDetail(id, offset) } + suspend fun refundDeposit(id: String, offset: UInt, address: String, network: UsdtDepositNetwork) = + usdt.operation { refundDeposit(id, offset, address, network) } +} diff --git a/app/src/main/java/to/bitkit/repositories/UsdtRepo.kt b/app/src/main/java/to/bitkit/repositories/UsdtRepo.kt new file mode 100644 index 0000000000..e73e3b2f1e --- /dev/null +++ b/app/src/main/java/to/bitkit/repositories/UsdtRepo.kt @@ -0,0 +1,209 @@ +package to.bitkit.repositories + +import androidx.compose.runtime.Stable +import com.synonym.bitkitcore.UsdtDestination +import com.synonym.bitkitcore.UsdtException +import com.synonym.bitkitcore.UsdtPaymentRequest +import com.synonym.bitkitcore.UsdtQuote +import com.synonym.bitkitcore.UsdtTransfer +import com.synonym.bitkitcore.UsdtTransferStatus +import com.synonym.bitkitcore.usdtParseAmount +import com.synonym.bitkitcore.usdtParsePaymentRequest +import com.synonym.bitkitcore.usdtValidateRecipient +import kotlinx.collections.immutable.ImmutableList +import kotlinx.collections.immutable.persistentListOf +import kotlinx.collections.immutable.toImmutableList +import kotlinx.coroutines.CoroutineDispatcher +import kotlinx.coroutines.delay +import kotlinx.coroutines.flow.MutableSharedFlow +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.asSharedFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.update +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock +import kotlinx.coroutines.withContext +import kotlinx.coroutines.withTimeoutOrNull +import to.bitkit.di.IoDispatcher +import to.bitkit.ext.nowMillis +import to.bitkit.ext.runSuspendCatching +import to.bitkit.models.PaykitUsdt +import to.bitkit.services.UsdtService +import java.text.DecimalFormatSymbols +import java.util.Locale +import javax.inject.Inject +import javax.inject.Singleton +import kotlin.time.Duration.Companion.seconds + +@Singleton +class UsdtRepo @Inject constructor( + private val service: UsdtService, + @IoDispatcher private val ioDispatcher: CoroutineDispatcher, +) { + private val mutex = Mutex() + + @Volatile var isSendPresented = false + + private var nextRefresh = 0L + private var rateLimitedUntil = 0L + private val _state = MutableStateFlow(UsdtWalletState()) + val state = _state.asStateFlow() + private val _receivedTxs = MutableSharedFlow(extraBufferCapacity = 8) + val receivedTxs = _receivedTxs.asSharedFlow() + + suspend fun refresh(history: Boolean, force: Boolean = false) = withContext(ioDispatcher) { + mutex.withLock { + val refreshAfter = if (force) rateLimitedUntil else maxOf(nextRefresh, rateLimitedUntil) + if (nowMillis() < refreshAfter) return@withLock Result.success(Unit) + runSuspendCatching { + val wallet = service.wallet() + val address = wallet.receiveAddress() + if (_state.value.address != address) _state.update { UsdtWalletState(address = address) } + val previous = _state.value.transfers.takeIf { _state.value.historyComplete } + val saved = wallet.history().toImmutableList() + _state.update { it.copy(receiveUri = wallet.receiveUri(), transfers = saved) } + val settlement = runSuspendCatching { + val balance = wallet.balance() + _state.update { it.copy(balance = balance) } + val transfers = wallet.refreshTransfers().toImmutableList() + _state.update { it.copy(transfers = transfers) } + } + if (settlement.exceptionOrNull() is UsdtException.RateLimited) settlement.getOrThrow() + if (history && !isSendPresented) { + val complete = wallet.syncHistory() + val current = wallet.history().toImmutableList() + _state.update { it.copy(historyComplete = it.historyComplete || complete, transfers = current) } + announceNewReceipts(previous, current) + } + settlement.getOrThrow() + }.also { + if (it.exceptionOrNull() is UsdtException.RateLimited) { + rateLimitedUntil = nowMillis() + 60.seconds.inWholeMilliseconds + } + nextRefresh = maxOf(rateLimitedUntil, nowMillis() + 10.seconds.inWholeMilliseconds) + } + } + } + + private suspend fun announceNewReceipts(previous: List?, current: List) { + if (previous == null) return + val knownIds = previous.filter { it.isIncoming && it.status == UsdtTransferStatus.CONFIRMED } + .map { it.id }.toSet() + current.filter { + it.isIncoming && it.status == UsdtTransferStatus.CONFIRMED && it.amount > 0u && it.id !in knownIds + }.forEach { _receivedTxs.emit(it) } + } + + suspend fun waitForTransfer(id: String): Result = withContext(ioDispatcher) { + withTimeoutOrNull(5.seconds) { + mutex.withLock { + if (nowMillis() < rateLimitedUntil) return@withLock Result.success(Unit) + runSuspendCatching { + val wallet = service.wallet() + while (true) { + val transfer = wallet.checkRecentExecution(id) ?: return@runSuspendCatching + _state.update { + val transfers = it.transfers.filter { saved -> saved.id != transfer.id } + it.copy(transfers = (listOf(transfer) + transfers).toImmutableList()) + } + if (transfer.status != UsdtTransferStatus.PENDING) return@runSuspendCatching + delay(1.seconds) + } + }.onFailure { + if (it is UsdtException.RateLimited) { + rateLimitedUntil = nowMillis() + 60.seconds.inWholeMilliseconds + nextRefresh = maxOf(nextRefresh, rateLimitedUntil) + } + } + } + } ?: Result.success(Unit) + } + + suspend fun paymentEndpoint(): Result = operation { PaykitUsdt.endpoint(wallet().receiveAddress()) } + + suspend fun sendDestinations() = operation { + (to.bitkit.env.Env.usdtDestinations + service.wallet().orchestraDestinations()).distinct().toImmutableList() + } + + fun backupSnapshot(): String? = service.backupSnapshot() + + suspend fun restoreBackup(snapshot: String) = withContext(ioDispatcher) { + mutex.withLock { + runSuspendCatching { + val wallet = service.wallet() + wallet.restoreBackup(snapshot) + _state.update { + it.copy( + address = wallet.receiveAddress(), + transfers = wallet.history().toImmutableList(), + historyComplete = false, + ) + } + } + } + } + + internal suspend fun operation(block: suspend UsdtService.() -> T): Result = withContext(ioDispatcher) { + mutex.withLock { runSuspendCatching { block(service) } } + } + + suspend fun wipe(clearCredentials: suspend () -> Unit = {}) = withContext(ioDispatcher) { + mutex.withLock { + clearCredentials() + runSuspendCatching { service.wipe() }.also { + _state.update { UsdtWalletState() } + nextRefresh = 0L + rateLimitedUntil = 0L + } + } + } + + suspend fun quote( + recipient: String, + amount: String, + destination: UsdtDestination, + locale: Locale = Locale.getDefault(), + ) = withContext(ioDispatcher) { + mutex.withLock { + runSuspendCatching { + service.wallet().quoteTransfer( + recipient, + usdtParseAmount(amount.replace(DecimalFormatSymbols.getInstance(locale).decimalSeparator, '.')), + destination + ) + } + } + } + + suspend fun send(quote: UsdtQuote) = withContext(ioDispatcher) { + mutex.withLock { + runSuspendCatching { + service.send(quote).also { transfer -> + _state.update { + it.copy( + transfers = (listOf(transfer) + it.transfers.filter { saved -> saved.id != transfer.id }) + .toImmutableList() + ) + } + } + } + } + } +} + +fun parseUsdtPaymentRequest(value: String, destination: UsdtDestination = UsdtDestination.ARBITRUM) = runCatching { + if (value.contains(':')) { + usdtParsePaymentRequest(value) + } else { + UsdtPaymentRequest(usdtValidateRecipient(value, destination), null, null) + } +} + +@Stable +data class UsdtWalletState( + val address: String = "", + val receiveUri: String = "", + val balance: ULong? = null, + val transfers: ImmutableList = persistentListOf(), + val historyComplete: Boolean = false, +) diff --git a/app/src/main/java/to/bitkit/services/PaykitSdkService.kt b/app/src/main/java/to/bitkit/services/PaykitSdkService.kt index fcd4038ad6..24b91fedb3 100644 --- a/app/src/main/java/to/bitkit/services/PaykitSdkService.kt +++ b/app/src/main/java/to/bitkit/services/PaykitSdkService.kt @@ -106,7 +106,6 @@ import to.bitkit.models.PubkyAuthRequestError import to.bitkit.models.PubkyPublicKeyFormat import to.bitkit.repositories.Endpoint import to.bitkit.repositories.PaykitBillingPeriod -import to.bitkit.repositories.PaykitIssuerInterop import to.bitkit.repositories.PubkyContactError import to.bitkit.repositories.PublicPaykitRepo import to.bitkit.services.PaykitSdkOperationLock.Priority @@ -144,11 +143,14 @@ data class PaykitResolvedPaymentEndpoint( data class PaykitPaymentRequestProposalTerms( val amountValue: String, + val amountAsset: String, val paymentReference: String, val proposalExpiresAt: String, val acceptedPaymentEndpointIdentifiers: List, val metadataJson: String, val recurrence: PaykitPaymentRequestRecurrenceTerms? = null, + val conversion: com.synonym.paykit.PaymentConversion? = null, + val paymentDeadline: com.synonym.paykit.PaymentDeadline? = null, ) data class PaykitPaymentRequestRecurrenceTerms( @@ -1051,7 +1053,7 @@ class PaykitSdkService @Inject constructor( PubkyPublicKeyFormat.matches(identityStatus.publicKey, expectedIdentity) ) { "Paykit identity changed before proposing the payment request" } val terms = PaymentRequestTerms( - amount = PaymentRequestAmount(proposal.amountValue, PaykitIssuerInterop.BITCOIN_ASSET), + amount = PaymentRequestAmount(proposal.amountValue, proposal.amountAsset), paymentReference = PaymentReference(proposal.paymentReference), proposalExpiresAt = proposal.proposalExpiresAt, recurrence = proposal.recurrence?.let { @@ -1066,8 +1068,8 @@ class PaykitSdkService @Inject constructor( acceptedPaymentEndpointIdentifiers = proposal.acceptedPaymentEndpointIdentifiers, paymentEndpoints = null, requiredAppId = "bitkit", - conversion = null, - paymentDeadline = null, + conversion = proposal.conversion, + paymentDeadline = proposal.paymentDeadline, metadata = PrivateJsonObject(proposal.metadataJson), ) completeSdkCall { handle.proposePaymentRequest(counterparty, terms) } @@ -1107,6 +1109,7 @@ class PaykitSdkService @Inject constructor( paymentEndpointIdentifier: String, proofJson: String, billingPeriod: PaykitBillingPeriod? = null, + conversionQuoteId: String? = null, ): PaymentRequestRecord { isSetup.await() return operationLock.withLock { @@ -1120,7 +1123,7 @@ class PaykitSdkService @Inject constructor( paymentAppId = paymentAppId, paymentEndpointIdentifier = paymentEndpointIdentifier, allowanceId = null, - conversionQuoteId = null, + conversionQuoteId = conversionQuoteId, proof = PrivateJsonObject(proofJson), ), ) @@ -1536,6 +1539,9 @@ class PaykitSdkService @Inject constructor( companion object { private const val TAG = "PaykitSdkService" + /** Maximum plaintext size accepted by Paykit's pubky-noise transport. */ + const val MAX_MESSAGE_BYTES = 1000 + /** Minimum delay between successful identity republications. */ private val IDENTITY_REPUBLISH_INTERVAL = 30.minutes diff --git a/app/src/main/java/to/bitkit/services/UsdtService.kt b/app/src/main/java/to/bitkit/services/UsdtService.kt new file mode 100644 index 0000000000..898376de29 --- /dev/null +++ b/app/src/main/java/to/bitkit/services/UsdtService.kt @@ -0,0 +1,131 @@ +package to.bitkit.services + +import com.synonym.bitkitcore.UsdtBackup +import com.synonym.bitkitcore.UsdtDepositClient +import com.synonym.bitkitcore.UsdtDepositNetwork +import com.synonym.bitkitcore.UsdtException +import com.synonym.bitkitcore.UsdtPaymentProofBinding +import com.synonym.bitkitcore.UsdtQuote +import com.synonym.bitkitcore.UsdtWallet +import com.synonym.bitkitcore.usdtAddress +import com.synonym.bitkitcore.usdtParseAmount +import to.bitkit.data.keychain.Keychain +import to.bitkit.env.Env +import to.bitkit.repositories.BackupRepo +import java.io.File +import java.io.IOException +import java.security.MessageDigest +import java.text.DecimalFormatSymbols +import java.util.Locale +import javax.inject.Inject +import javax.inject.Provider +import javax.inject.Singleton + +@Singleton +class UsdtService @Inject constructor( + private val keychain: Keychain, + private val backupRepo: Provider, +) { + private var wallet: UsdtWallet? = null + private var credentialFingerprint: ByteArray? = null + + @Synchronized + fun wallet(): UsdtWallet { + if (!Env.isUsdtEnabled) throw UsdtException.NotConfigured() + val mnemonic = keychain.loadString(Keychain.Key.BIP39_MNEMONIC.name) ?: throw UsdtException.InvalidCredentials() + val passphrase = keychain.loadString(Keychain.Key.BIP39_PASSPHRASE.name) + val fingerprint = MessageDigest.getInstance("SHA-256") + .digest("${mnemonic.length}:$mnemonic${passphrase.orEmpty()}".encodeToByteArray()) + if (credentialFingerprint?.contentEquals(fingerprint) != true) { + wallet?.close() + wallet = null + } + wallet?.let { return it } + val address = usdtAddress(mnemonic, passphrase) + return UsdtWallet( + address = address, + storagePath = File(Env.bitkitCoreStoragePath(0), "usdt-$address.sqlite").path, + rpcUrl = requireNotNull(Env.usdtRpcUrl), + bundlerUrl = Env.usdtBundlerUrl, + bridgeUrl = Env.usdtBridgesUrl, + backup = object : UsdtBackup { + override suspend fun persist(snapshot: String) { + backupRepo.get().persistWalletBackup(snapshot).getOrElse { throw UsdtException.BackupUnavailable() } + } + }, + ).also { + wallet = it + credentialFingerprint = fingerprint + } + } + + suspend fun depositNetworks(): List { + if (Env.usdtDepositsUrl == null) return emptyList() + return withDeposits { client, _, _ -> client.networks() } + } + + suspend fun prepareDeposit(network: UsdtDepositNetwork, amount: String, locale: Locale = Locale.getDefault()) = + withDeposits { client, mnemonic, passphrase -> + val value = usdtParseAmount(amount.replace(DecimalFormatSymbols.getInstance(locale).decimalSeparator, '.')) + client.receive(network, value, mnemonic, passphrase) + } + + suspend fun depositHistory(offset: UInt) = withDeposits { client, mnemonic, passphrase -> + client.history(offset, mnemonic, passphrase) + } + + suspend fun depositDetail(id: String, offset: UInt) = withDeposits { client, mnemonic, passphrase -> + client.detail(id, offset, mnemonic, passphrase) + } + + suspend fun refundDeposit(id: String, offset: UInt, address: String, network: UsdtDepositNetwork) = + withDeposits { client, mnemonic, passphrase -> + client.requestRefund(id, offset, address, network, mnemonic, passphrase) + } + + private suspend fun withDeposits(block: suspend (UsdtDepositClient, String, String?) -> T): T { + val mnemonic = keychain.loadString(Keychain.Key.BIP39_MNEMONIC.name) ?: throw UsdtException.InvalidCredentials() + val passphrase = keychain.loadString(Keychain.Key.BIP39_PASSPHRASE.name) + val owner = usdtAddress(mnemonic, passphrase) + val client = UsdtDepositClient(owner, requireNotNull(Env.usdtDepositsUrl)) + return try { block(client, mnemonic, passphrase) } finally { client.close() } + } + + @Synchronized + fun backupSnapshot(): String? { + if (Env.isUsdtEnabled) return wallet().exportBackup() + val directory = File(Env.bitkitCoreStoragePath(0)) + if (directory.exists()) { + val files = directory.listFiles() ?: throw IOException("Cannot read USDT storage") + if (files.any { it.name.startsWith("usdt-") && it.extension == "sqlite" }) { + throw UsdtException.NotConfigured() + } + } + return null + } + + @Synchronized + fun wipe() { + wallet?.close() + wallet = null + credentialFingerprint = null + val directory = File(Env.bitkitCoreStoragePath(0)) + if (!directory.exists()) return + val files = directory.listFiles() ?: throw IOException("Cannot read USDT storage") + files.filter { it.name.startsWith("usdt-") && it.extension in setOf("sqlite", "sqlite-wal", "sqlite-shm") } + .forEach { if (!it.delete()) throw IOException("Cannot delete USDT storage") } + } + + suspend fun paymentProof(quoteId: String, binding: UsdtPaymentProofBinding) = wallet().createPaymentProof( + quoteId, + binding, + keychain.loadString(Keychain.Key.BIP39_MNEMONIC.name) ?: throw UsdtException.InvalidCredentials(), + keychain.loadString(Keychain.Key.BIP39_PASSPHRASE.name) + ) + + suspend fun send(quote: UsdtQuote) = wallet().send( + quote.id, + keychain.loadString(Keychain.Key.BIP39_MNEMONIC.name) ?: throw UsdtException.InvalidCredentials(), + keychain.loadString(Keychain.Key.BIP39_PASSPHRASE.name) + ) +} diff --git a/app/src/main/java/to/bitkit/ui/ContentView.kt b/app/src/main/java/to/bitkit/ui/ContentView.kt index 8a41a6bcd2..3647abc3d8 100644 --- a/app/src/main/java/to/bitkit/ui/ContentView.kt +++ b/app/src/main/java/to/bitkit/ui/ContentView.kt @@ -165,6 +165,7 @@ import to.bitkit.ui.screens.wallets.receive.ReceiveRoute import to.bitkit.ui.screens.wallets.receive.ReceiveSheet import to.bitkit.ui.screens.wallets.send.HwSendViewModel import to.bitkit.ui.screens.wallets.suggestion.BuyIntroScreen +import to.bitkit.ui.screens.wallets.usdt.UsdtWalletScreen import to.bitkit.ui.screens.widgets.WidgetsIntroScreen import to.bitkit.ui.settings.BackupSettingsScreen import to.bitkit.ui.settings.BlocktankRegtestScreen @@ -486,7 +487,8 @@ fun ContentView( val isCreatingPaymentRequest by appViewModel.isCreatingPaymentRequest.collectAsStateWithLifecycle() val hwSendViewModel = hiltViewModel() val hwSendUiState by hwSendViewModel.uiState.collectAsStateWithLifecycle() - val canDismissSheet = currentSheet !is Sheet.Send || hwSendUiState.canLeave + val canDismissSheet = currentSheet !is Sheet.Send || + (hwSendUiState.canLeave && !appViewModel.isPaykitUsdtBusy) val isAcceptingSubscription by appViewModel.isAcceptingSubscription.collectAsStateWithLifecycle() val isRetryingInitialSubscriptionPayment by appViewModel.isRetryingInitialSubscriptionPayment.collectAsStateWithLifecycle() @@ -1213,6 +1215,9 @@ private fun NavGraphBuilder.home( ) } } + deepLinkableComposable { + UsdtWalletScreen(onBack = { navController.popBackStack() }) + } deepLinkableComposable { val hasSeenSpendingIntro by settingsViewModel.hasSeenSpendingIntro.collectAsStateWithLifecycle() val isGeoBlocked by appViewModel.isGeoBlocked.collectAsStateWithLifecycle() @@ -1429,8 +1434,13 @@ private fun NavGraphBuilder.contacts( ContactDetailScreen( viewModel = viewModel, onBackClick = { navController.popBackStack() }, - onPayContact = { paymentRequest, publicKey, privatePaymentContext -> - appViewModel.openContactPayment(paymentRequest, publicKey, privatePaymentContext) + onPayContact = { paymentRequest, publicKey, privatePaymentContext, endpoints -> + appViewModel.openContactPayment( + paymentRequest, + publicKey, + privatePaymentContext, + endpoints = endpoints + ) }, onActivityClick = { navController.navigateTo(Routes.ContactActivity(it)) }, onRequestPayment = { @@ -1473,9 +1483,9 @@ private fun NavGraphBuilder.contacts( popUpTo(Routes.AddContact(publicKey)) { inclusive = true } } }, - onPayContact = { paymentRequest, publicKey -> + onPayContact = { paymentRequest, publicKey, endpoints -> navController.popBackStack() - appViewModel.openContactPayment(paymentRequest, publicKey) + appViewModel.openContactPayment(paymentRequest, publicKey, endpoints = endpoints) }, ) } @@ -2223,6 +2233,9 @@ sealed interface Routes { @Serializable data class HardwareWallet(val walletId: String) : Routes.DeepLinkable + @Serializable + data object UsdtWallet : Routes.DeepLinkable + @Serializable data object Settings : Routes.DeepLinkable diff --git a/app/src/main/java/to/bitkit/ui/MainActivity.kt b/app/src/main/java/to/bitkit/ui/MainActivity.kt index c17983214f..026af29844 100644 --- a/app/src/main/java/to/bitkit/ui/MainActivity.kt +++ b/app/src/main/java/to/bitkit/ui/MainActivity.kt @@ -254,10 +254,12 @@ class MainActivity : FragmentActivity() { ) val transactionSheetDetails by appViewModel.transactionSheet.collectAsStateWithLifecycle() + val hideBalance by settingsViewModel.hideBalance.collectAsStateWithLifecycle() if (isAuthenticated && transactionSheetDetails != NewTransactionSheetDetails.EMPTY) { NewTransactionSheet( appViewModel = appViewModel, bottomSheetOverlayState = bottomSheetOverlayState, + hideBalance = hideBalance, ) } diff --git a/app/src/main/java/to/bitkit/ui/components/Money.kt b/app/src/main/java/to/bitkit/ui/components/Money.kt index ac452290f6..0558d9c7ce 100644 --- a/app/src/main/java/to/bitkit/ui/components/Money.kt +++ b/app/src/main/java/to/bitkit/ui/components/Money.kt @@ -33,11 +33,12 @@ fun MoneyDisplay( modifier: Modifier = Modifier, onClick: (() -> Unit)? = null, showSymbol: Boolean = true, + prefix: String = "", ) { val text = rememberMoneyText(sats, showSymbol = showSymbol) text?.let { Display( - text = it.withAccent( + text = "$prefix$it".withAccent( accentStyle = SpanStyle( color = Colors.White64, fontWeight = FontWeight.ExtraBold, diff --git a/app/src/main/java/to/bitkit/ui/components/NumberPadActionButton.kt b/app/src/main/java/to/bitkit/ui/components/NumberPadActionButton.kt index 5ce80f2237..e4d31ccd5b 100644 --- a/app/src/main/java/to/bitkit/ui/components/NumberPadActionButton.kt +++ b/app/src/main/java/to/bitkit/ui/components/NumberPadActionButton.kt @@ -35,6 +35,7 @@ fun NumberPadActionButton( enabled: Boolean = true, isLoading: Boolean = false, clickable: Boolean = true, + outlined: Boolean = false, @DrawableRes icon: Int? = null, ) { val contentPadding = PaddingValues(horizontal = 8.dp, vertical = 5.dp) @@ -47,9 +48,12 @@ fun NumberPadActionButton( horizontalArrangement = Arrangement.spacedBy(8.dp), modifier = modifier .requiredHeight(height) - .primaryButtonStyle( - isEnabled = enabled || isLoading, - shape = buttonShape, + .then( + if (outlined) { + Modifier.border(width = 1.dp, color = color, shape = buttonShape) + } else { + Modifier.primaryButtonStyle(isEnabled = enabled || isLoading, shape = buttonShape) + } ) .animateContentSize(animationSpec = tween(durationMillis = 200)) .clickableAlpha(enabled = enabled && clickable && !isLoading, onClick = onClick) diff --git a/app/src/main/java/to/bitkit/ui/components/NumberPadTextField.kt b/app/src/main/java/to/bitkit/ui/components/NumberPadTextField.kt index ee31a2321a..4be1c44c8c 100644 --- a/app/src/main/java/to/bitkit/ui/components/NumberPadTextField.kt +++ b/app/src/main/java/to/bitkit/ui/components/NumberPadTextField.kt @@ -16,7 +16,6 @@ import androidx.compose.ui.semantics.contentDescription import androidx.compose.ui.semantics.semantics import androidx.compose.ui.text.SpanStyle import androidx.compose.ui.text.buildAnnotatedString -import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.text.withStyle import androidx.compose.ui.tooling.preview.Preview import androidx.compose.ui.unit.dp @@ -93,52 +92,16 @@ private fun MoneyAmount( ) VerticalSpacer(12.dp) } - Row( - verticalAlignment = Alignment.CenterVertically, - modifier = Modifier.fillMaxWidth() - ) { - if (!isSymbolSuffix) { - Display( - text = symbol, - fontWeight = FontWeight.ExtraBold, - color = Colors.White64, - modifier = Modifier.padding(end = 6.dp) - ) - } - Display( - text = buildAnnotatedString { - if (value != placeholder) { - withStyle(valueStyle) { - append(value) - } - } - if (placeholder.isNotEmpty() && showPlaceholder) { - withStyle(placeholderStyle) { - append(placeholder) - } - } - }, - modifier = Modifier.weight(1f, fill = false) - ) - if (isSymbolSuffix) { - Display( - text = symbol, - fontWeight = FontWeight.ExtraBold, - color = Colors.White64, - modifier = Modifier.padding(start = 6.dp) - ) - } - if (showEditButton) { - Icon( - painter = painterResource(R.drawable.ic_pencil_simple), - contentDescription = stringResource(R.string.common__edit), - tint = Colors.White, - modifier = Modifier - .padding(start = 5.dp) - .size(24.dp) - ) - } - } + NumberPadAmountText( + showEditButton = showEditButton, + value = value, + placeholder = placeholder, + symbol = symbol, + isSymbolSuffix = isSymbolSuffix, + showPlaceholder = showPlaceholder, + valueStyle = valueStyle, + placeholderStyle = placeholderStyle, + ) } } @@ -242,3 +205,59 @@ private fun PreviewModernValue() { ) } } + +@Composable +fun NumberPadAmountText( + value: String, + symbol: String, + modifier: Modifier = Modifier, + showEditButton: Boolean = false, + placeholder: String = "", + isSymbolSuffix: Boolean = false, + showPlaceholder: Boolean = true, + valueStyle: SpanStyle = SpanStyle(color = Colors.White), + placeholderStyle: SpanStyle = SpanStyle(color = Colors.White50), +) { + Row( + verticalAlignment = Alignment.CenterVertically, + modifier = modifier.fillMaxWidth() + ) { + if (!isSymbolSuffix) { + Display( + text = symbol, + color = Colors.White64, + modifier = Modifier.padding(end = 6.dp) + ) + } + Display( + text = buildAnnotatedString { + if (value != placeholder) { + withStyle(valueStyle) { + append(value) + } + } + if (placeholder.isNotEmpty() && showPlaceholder) { + withStyle(placeholderStyle) { + append(placeholder) + } + } + }, + modifier = Modifier.weight(1f, fill = false) + ) + if (isSymbolSuffix) { + Display( + text = symbol, + color = Colors.White64, + modifier = Modifier.padding(start = 6.dp) + ) + } + if (showEditButton) { + Icon( + painter = painterResource(R.drawable.ic_pencil_simple), + contentDescription = stringResource(R.string.common__edit), + tint = Colors.White, + modifier = Modifier.padding(start = 5.dp).size(24.dp) + ) + } + } +} diff --git a/app/src/main/java/to/bitkit/ui/components/PaykitAmountView.kt b/app/src/main/java/to/bitkit/ui/components/PaykitAmountView.kt new file mode 100644 index 0000000000..b3605b4d2e --- /dev/null +++ b/app/src/main/java/to/bitkit/ui/components/PaykitAmountView.kt @@ -0,0 +1,43 @@ +package to.bitkit.ui.components + +import androidx.compose.foundation.layout.Column +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset +import to.bitkit.ui.theme.Colors + +@Composable +fun PaykitAmountDisplay(amount: PaykitAmount, prefix: String = "") { + if (amount.asset == PaykitAsset.BTC) { + MoneyDisplay( + sats = amount.atomic.coerceAtMost(Long.MAX_VALUE.toULong()).toLong(), + showSymbol = true, + prefix = prefix, + ) + } else { + NumberPadAmountText(value = prefix + amount.value, symbol = if (amount.asset == PaykitAsset.USD) "$" else "₮") + } +} + +@Composable +fun PaykitAmountCell( + amount: PaykitAmount, + prefix: String = "", + status: String? = null, + showBitcoinSymbol: Boolean = true +) { + if (amount.asset == PaykitAsset.BTC) { + MoneyCell( + sats = amount.atomic.coerceAtMost(Long.MAX_VALUE.toULong()).toLong(), + prefix = prefix, + showBitcoinSymbol = showBitcoinSymbol, + fiatReplacement = status + ) + } else { + Column(horizontalAlignment = Alignment.End) { + BodyMSB(text = prefix + (if (amount.asset == PaykitAsset.USD) "$" else "₮") + amount.value) + status?.let { BodyS(text = it, color = Colors.White64) } + } + } +} diff --git a/app/src/main/java/to/bitkit/ui/components/PaymentAddressInput.kt b/app/src/main/java/to/bitkit/ui/components/PaymentAddressInput.kt new file mode 100644 index 0000000000..8690cff958 --- /dev/null +++ b/app/src/main/java/to/bitkit/ui/components/PaymentAddressInput.kt @@ -0,0 +1,30 @@ +package to.bitkit.ui.components + +import androidx.compose.foundation.text.KeyboardOptions +import androidx.compose.runtime.Composable +import androidx.compose.ui.Modifier +import androidx.compose.ui.text.input.ImeAction +import androidx.compose.ui.text.input.KeyboardCapitalization +import to.bitkit.ui.theme.AppTextStyles + +@Composable +fun PaymentAddressInput( + value: String, + onValueChange: (String) -> Unit, + placeholder: String, + modifier: Modifier = Modifier, +) { + TextInput( + value = value, + onValueChange = onValueChange, + placeholder = placeholder, + minLines = 12, + keyboardOptions = KeyboardOptions( + capitalization = KeyboardCapitalization.None, + imeAction = ImeAction.Done, + autoCorrectEnabled = false, + ), + textStyle = AppTextStyles.Title, + modifier = modifier + ) +} diff --git a/app/src/main/java/to/bitkit/ui/components/PaymentReviewIllustration.kt b/app/src/main/java/to/bitkit/ui/components/PaymentReviewIllustration.kt new file mode 100644 index 0000000000..ae9ed1bca1 --- /dev/null +++ b/app/src/main/java/to/bitkit/ui/components/PaymentReviewIllustration.kt @@ -0,0 +1,30 @@ +package to.bitkit.ui.components + +import androidx.compose.foundation.Image +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.graphicsLayer +import androidx.compose.ui.layout.ContentScale +import androidx.compose.ui.res.painterResource +import androidx.compose.ui.unit.dp +import to.bitkit.R + +private const val IMAGE_FILL_PERCENTAGE = 0.8f +private const val SWIPE_ROTATION_DEGREES = 14f + +@Composable +fun PaymentReviewIllustration(swipeProgress: () -> Float, modifier: Modifier = Modifier) { + Box(contentAlignment = Alignment.Center, modifier = modifier.fillMaxWidth()) { + Image( + painter = painterResource(R.drawable.coin_stack_4), + contentDescription = null, + contentScale = ContentScale.Fit, + modifier = Modifier.fillMaxWidth(IMAGE_FILL_PERCENTAGE).padding(bottom = 16.dp) + .graphicsLayer { rotationZ = swipeProgress() * SWIPE_ROTATION_DEGREES } + ) + } +} diff --git a/app/src/main/java/to/bitkit/ui/components/UsdtAmountHeader.kt b/app/src/main/java/to/bitkit/ui/components/UsdtAmountHeader.kt new file mode 100644 index 0000000000..e28de5a7be --- /dev/null +++ b/app/src/main/java/to/bitkit/ui/components/UsdtAmountHeader.kt @@ -0,0 +1,30 @@ +package to.bitkit.ui.components + +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.runtime.Composable +import androidx.compose.ui.Modifier + +@Composable +internal fun UsdtAmountHeader( + amount: String, + network: String, + modifier: Modifier = Modifier, + hideBalance: Boolean = false, + prefix: String? = null, + onToggleHide: (() -> Unit)? = null, + onClick: () -> Unit = {}, +) { + BalanceHeader( + isBitcoinPrimary = false, + smallRowText = "USDT · $network", + largeRowText = amount, + largeRowSymbol = "₮", + largeRowPrefix = prefix, + showSymbol = true, + hideBalance = hideBalance, + onClick = onClick, + isSwipeToHideEnabled = onToggleHide != null, + onToggleHideBalance = { onToggleHide?.invoke() }, + modifier = modifier.fillMaxWidth() + ) +} diff --git a/app/src/main/java/to/bitkit/ui/components/WalletBalanceView.kt b/app/src/main/java/to/bitkit/ui/components/WalletBalanceView.kt index 70020ecac2..6adde6541c 100644 --- a/app/src/main/java/to/bitkit/ui/components/WalletBalanceView.kt +++ b/app/src/main/java/to/bitkit/ui/components/WalletBalanceView.kt @@ -100,67 +100,52 @@ private fun RowScope.Content( hideBalance: Boolean, titleTrailing: @Composable RowScope.() -> Unit = {}, ) { - Column( - modifier = Modifier - .weight(1f) - .then(modifier) - ) { - Row(verticalAlignment = Alignment.CenterVertically) { - Text13Up( - text = title, - color = Colors.White64, - maxLines = 1, - modifier = Modifier.weight(1f, fill = false) - ) - titleTrailing() - } - VerticalSpacer(8.dp) - - converted?.let { converted -> - Row( - verticalAlignment = Alignment.CenterVertically, - horizontalArrangement = Arrangement.spacedBy(4.dp), - ) { + WalletBalanceContent( + title = title, + icon = { + if (converted != null) { Icon( painter = icon, contentDescription = title, tint = Color.Unspecified, - modifier = Modifier - .padding(end = 4.dp) - .size(24.dp) + modifier = Modifier.padding(end = 4.dp).size(24.dp) ) - - if (primaryDisplay == PrimaryDisplay.BITCOIN) { - val btcComponents = converted.bitcoinDisplay(displayUnit) - AnimatedContent( - targetState = hideBalance, - transitionSpec = { BalanceAnimations.walletBalanceTransition }, - label = "bitcoinBalanceAnimation" - ) { isHidden -> - Row( - verticalAlignment = Alignment.CenterVertically, - horizontalArrangement = Arrangement.spacedBy(4.dp), - ) { - BodyMSB(text = if (isHidden) UiConstants.HIDE_BALANCE_SHORT else btcComponents.value) - } + } + }, + titleTrailing = titleTrailing, + modifier = modifier, + ) { + converted?.let { converted -> + if (primaryDisplay == PrimaryDisplay.BITCOIN) { + val btcComponents = converted.bitcoinDisplay(displayUnit) + AnimatedContent( + targetState = hideBalance, + transitionSpec = { BalanceAnimations.walletBalanceTransition }, + label = "bitcoinBalanceAnimation" + ) { isHidden -> + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(4.dp), + ) { + BodyMSB(text = if (isHidden) UiConstants.HIDE_BALANCE_SHORT else btcComponents.value) } - } else { - AnimatedContent( - targetState = hideBalance, - transitionSpec = { BalanceAnimations.walletBalanceTransition }, - label = "fiatBalanceAnimation" - ) { isHidden -> - Row( - verticalAlignment = Alignment.CenterVertically, - horizontalArrangement = Arrangement.spacedBy(4.dp), - ) { - if (converted.isSymbolSuffix) { - BodyMSB(text = if (isHidden) UiConstants.HIDE_BALANCE_SHORT else converted.formatted) - BodyMSB(text = converted.symbol) - } else { - BodyMSB(text = converted.symbol) - BodyMSB(text = if (isHidden) UiConstants.HIDE_BALANCE_SHORT else converted.formatted) - } + } + } else { + AnimatedContent( + targetState = hideBalance, + transitionSpec = { BalanceAnimations.walletBalanceTransition }, + label = "fiatBalanceAnimation" + ) { isHidden -> + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(4.dp), + ) { + if (converted.isSymbolSuffix) { + BodyMSB(text = if (isHidden) UiConstants.HIDE_BALANCE_SHORT else converted.formatted) + BodyMSB(text = converted.symbol) + } else { + BodyMSB(text = converted.symbol) + BodyMSB(text = if (isHidden) UiConstants.HIDE_BALANCE_SHORT else converted.formatted) } } } @@ -169,6 +154,27 @@ private fun RowScope.Content( } } +@Composable +fun RowScope.WalletBalanceContent( + title: String, + icon: @Composable () -> Unit, + modifier: Modifier = Modifier, + titleTrailing: @Composable RowScope.() -> Unit = {}, + amount: @Composable () -> Unit, +) { + Column(modifier = Modifier.weight(1f).then(modifier)) { + Row(verticalAlignment = Alignment.CenterVertically) { + Text13Up(text = title, color = Colors.White64, maxLines = 1, modifier = Modifier.weight(1f, fill = false)) + titleTrailing() + } + VerticalSpacer(8.dp) + Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(4.dp)) { + icon() + amount() + } + } +} + @Preview @Composable private fun Preview() { diff --git a/app/src/main/java/to/bitkit/ui/screens/contacts/AddContactScreen.kt b/app/src/main/java/to/bitkit/ui/screens/contacts/AddContactScreen.kt index 63ae007ec6..1fd030fb7b 100644 --- a/app/src/main/java/to/bitkit/ui/screens/contacts/AddContactScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/contacts/AddContactScreen.kt @@ -57,6 +57,7 @@ import to.bitkit.ext.getClipboardText import to.bitkit.models.PubkyProfile import to.bitkit.models.PubkyProfileLink import to.bitkit.models.PubkyPublicKeyFormat +import to.bitkit.repositories.Endpoint import to.bitkit.ui.components.BodyM import to.bitkit.ui.components.BodyS import to.bitkit.ui.components.BottomSheet @@ -240,7 +241,7 @@ fun AddContactScreen( viewModel: AddContactViewModel, onBackClick: () -> Unit, onContactSaved: (String) -> Unit, - onPayContact: (String, String) -> Unit, + onPayContact: (String, String, List) -> Unit, ) { val uiState by viewModel.uiState.collectAsStateWithLifecycle() @@ -248,7 +249,7 @@ fun AddContactScreen( viewModel.effects.collect { when (it) { is AddContactEffect.ContactSaved -> onContactSaved(it.publicKey) - is AddContactEffect.OpenPayment -> onPayContact(it.paymentRequest, it.publicKey) + is AddContactEffect.OpenPayment -> onPayContact(it.paymentRequest, it.publicKey, it.endpoints) } } } diff --git a/app/src/main/java/to/bitkit/ui/screens/contacts/AddContactViewModel.kt b/app/src/main/java/to/bitkit/ui/screens/contacts/AddContactViewModel.kt index d4818aafbb..eb93d9c708 100644 --- a/app/src/main/java/to/bitkit/ui/screens/contacts/AddContactViewModel.kt +++ b/app/src/main/java/to/bitkit/ui/screens/contacts/AddContactViewModel.kt @@ -18,6 +18,7 @@ import to.bitkit.R import to.bitkit.models.PubkyProfile import to.bitkit.models.PubkyPublicKeyFormat import to.bitkit.models.Toast +import to.bitkit.repositories.Endpoint import to.bitkit.repositories.PubkyContactError import to.bitkit.repositories.PubkyRepo import to.bitkit.repositories.PublicPaykitPaymentResult @@ -121,7 +122,9 @@ class AddContactViewModel @Inject constructor( .onSuccess { result -> when (result) { is PublicPaykitPaymentResult.Opened -> - _effects.emit(AddContactEffect.OpenPayment(result.paymentRequest, profile.publicKey)) + _effects.emit( + AddContactEffect.OpenPayment(result.paymentRequest, profile.publicKey, result.endpoints) + ) PublicPaykitPaymentResult.NoEndpoint -> showPayError(R.string.slashtags__error_pay_empty_msg) PublicPaykitPaymentResult.NotOpened -> @@ -185,5 +188,9 @@ data class AddContactUiState( sealed interface AddContactEffect { data class ContactSaved(val publicKey: String) : AddContactEffect - data class OpenPayment(val paymentRequest: String, val publicKey: String) : AddContactEffect + data class OpenPayment( + val paymentRequest: String, + val publicKey: String, + val endpoints: List = emptyList() + ) : AddContactEffect } diff --git a/app/src/main/java/to/bitkit/ui/screens/contacts/ContactDetailScreen.kt b/app/src/main/java/to/bitkit/ui/screens/contacts/ContactDetailScreen.kt index d861534525..45f978c674 100644 --- a/app/src/main/java/to/bitkit/ui/screens/contacts/ContactDetailScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/contacts/ContactDetailScreen.kt @@ -36,6 +36,7 @@ import kotlinx.coroutines.Job import to.bitkit.R import to.bitkit.models.PubkyProfile import to.bitkit.models.PubkyProfileLink +import to.bitkit.repositories.Endpoint import to.bitkit.repositories.PaykitPaymentRequestTarget import to.bitkit.repositories.PrivatePaykitPaymentContext import to.bitkit.ui.components.ActionButton @@ -70,7 +71,7 @@ import to.bitkit.ui.utils.withAccent fun ContactDetailScreen( viewModel: ContactDetailViewModel, onBackClick: () -> Unit, - onPayContact: (String, String, PrivatePaykitPaymentContext?) -> Job?, + onPayContact: (String, String, PrivatePaykitPaymentContext?, List) -> Job?, onActivityClick: (String) -> Unit, onRequestPayment: (PaykitPaymentRequestTarget) -> Unit = {}, showDeleteAction: Boolean = false, @@ -88,7 +89,7 @@ fun ContactDetailScreen( viewModel.effects.collect { when (it) { is ContactDetailEffect.OpenPayment -> { - val scanJob = onPayContact(it.paymentRequest, it.publicKey, it.privatePaymentContext) + val scanJob = onPayContact(it.paymentRequest, it.publicKey, it.privatePaymentContext, it.endpoints) viewModel.onPaymentOpening(scanJob) } ContactDetailEffect.ContactDeleted -> onContactDeleted() diff --git a/app/src/main/java/to/bitkit/ui/screens/contacts/ContactDetailViewModel.kt b/app/src/main/java/to/bitkit/ui/screens/contacts/ContactDetailViewModel.kt index 43903caf0a..73d0848a30 100644 --- a/app/src/main/java/to/bitkit/ui/screens/contacts/ContactDetailViewModel.kt +++ b/app/src/main/java/to/bitkit/ui/screens/contacts/ContactDetailViewModel.kt @@ -32,6 +32,7 @@ import to.bitkit.models.PubkyProfile import to.bitkit.models.PubkyProfileLink import to.bitkit.models.PubkyPublicKeyFormat import to.bitkit.models.Toast +import to.bitkit.repositories.Endpoint import to.bitkit.repositories.PaykitPaymentRequestRepo import to.bitkit.repositories.PaykitPaymentRequestTarget import to.bitkit.repositories.PrivatePaykitPaymentContext @@ -240,6 +241,7 @@ class ContactDetailViewModel @Inject constructor( it.paymentRequest, publicKey, it.privatePaymentContext, + it.endpoints, ) ) } @@ -420,6 +422,7 @@ sealed interface ContactDetailEffect { val paymentRequest: String, val publicKey: String, val privatePaymentContext: PrivatePaykitPaymentContext?, + val endpoints: List = emptyList(), ) : ContactDetailEffect data object ContactDeleted : ContactDetailEffect diff --git a/app/src/main/java/to/bitkit/ui/screens/paymentrequests/CreatePaymentRequestScreen.kt b/app/src/main/java/to/bitkit/ui/screens/paymentrequests/CreatePaymentRequestScreen.kt index ab04f43d03..392547cf52 100644 --- a/app/src/main/java/to/bitkit/ui/screens/paymentrequests/CreatePaymentRequestScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/paymentrequests/CreatePaymentRequestScreen.kt @@ -44,13 +44,17 @@ import kotlinx.collections.immutable.persistentListOf import kotlinx.collections.immutable.toImmutableList import to.bitkit.R import to.bitkit.ext.getClipboardText +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset import to.bitkit.models.PubkyProfile import to.bitkit.models.PubkyPublicKeyFormat +import to.bitkit.repositories.MethodId import to.bitkit.repositories.PaykitPaymentRequest import to.bitkit.repositories.PaykitPaymentRequestDeliveryStatus import to.bitkit.repositories.PaykitPaymentRequestDirection import to.bitkit.repositories.PaykitPaymentRequestDraft import to.bitkit.repositories.PaykitPaymentRequestTarget +import to.bitkit.repositories.paykitRate import to.bitkit.ui.LocalCurrencies import to.bitkit.ui.components.BodyM import to.bitkit.ui.components.BodyMSB @@ -61,24 +65,26 @@ import to.bitkit.ui.components.CaptionB import to.bitkit.ui.components.Display import to.bitkit.ui.components.FillHeight import to.bitkit.ui.components.FillWidth -import to.bitkit.ui.components.MoneyCell -import to.bitkit.ui.components.MoneyDisplay import to.bitkit.ui.components.NumberPad +import to.bitkit.ui.components.NumberPadActionButton +import to.bitkit.ui.components.NumberPadAmountText import to.bitkit.ui.components.NumberPadTextField +import to.bitkit.ui.components.NumberPadType +import to.bitkit.ui.components.PaykitAmountCell +import to.bitkit.ui.components.PaykitAmountDisplay import to.bitkit.ui.components.PrimaryButton import to.bitkit.ui.components.PubkyContactAvatar import to.bitkit.ui.components.PubkyContactRow import to.bitkit.ui.components.TextInput import to.bitkit.ui.components.UnitButton import to.bitkit.ui.components.VerticalSpacer -import to.bitkit.ui.components.rememberMoneyText import to.bitkit.ui.scaffold.SheetTopBar import to.bitkit.ui.shared.modifiers.clickableAlpha import to.bitkit.ui.shared.modifiers.sheetHeight import to.bitkit.ui.shared.util.gradientBackground import to.bitkit.ui.theme.AppThemeSurface import to.bitkit.ui.theme.Colors -import to.bitkit.ui.utils.removeAccentTags +import to.bitkit.ui.utils.NumberPadInputHandler import to.bitkit.ui.utils.withAccent import to.bitkit.viewmodels.AmountInputViewModel import to.bitkit.viewmodels.AppViewModel @@ -135,11 +141,23 @@ internal fun PaymentRequestAmountContent( val currencies = LocalCurrencies.current val amountState by amountInputViewModel.uiState.collectAsStateWithLifecycle() - LaunchedEffect(initialDraft.amountSats) { - amountInputViewModel.setSats( - initialDraft.amountSats.coerceAtMost(Long.MAX_VALUE.toULong()).toLong(), - currencies, - ) + var asset by remember(initialDraft.amount.asset) { mutableStateOf(initialDraft.amount.asset) } + var dollars by remember(initialDraft.amount) { + mutableStateOf(if (initialDraft.amount.asset != PaykitAsset.BTC) initialDraft.amount.value else "") + } + var conversionError by remember { mutableStateOf(false) } + val entered = if (asset == PaykitAsset.BTC) { + PaykitAmount(asset, amountState.sats.toULong()) + } else { + runCatching { PaykitAmount.parse(asset, dollars) }.getOrNull() + } + LaunchedEffect(initialDraft.amount) { + if (initialDraft.amount.asset == PaykitAsset.BTC) { + amountInputViewModel.setSats( + initialDraft.amount.atomic.coerceAtMost(Long.MAX_VALUE.toULong()).toLong(), + currencies + ) + } } Column( @@ -167,34 +185,76 @@ internal fun PaymentRequestAmountContent( Column(modifier = Modifier.fillMaxSize().padding(horizontal = 16.dp)) { VerticalSpacer(16.dp) - NumberPadTextField( - viewModel = amountInputViewModel, - modifier = Modifier - .fillMaxWidth() - .testTag("PaymentRequestAmountField"), + if (asset == PaykitAsset.BTC) { + NumberPadTextField( + viewModel = amountInputViewModel, + modifier = Modifier.fillMaxWidth().testTag("PaymentRequestAmountField") + ) + } else { + NumberPadAmountText( + value = dollars.ifEmpty { "0" }, + symbol = "$", + modifier = Modifier.testTag("PaymentRequestAmountField") + ) + } + VerticalSpacer(16.dp) + PaymentRequestAssetSelector( + asset = asset, + amount = entered, + onConverted = { + asset = it.asset + if (it.asset == PaykitAsset.BTC) { + amountInputViewModel.setSats(it.atomic.toLong(), currencies) + } else { + dollars = if (it.atomic == 0uL) "" else it.value + } + conversionError = false + }, + onUnavailable = { conversionError = true }, ) - FillHeight(min = 12.dp) - Row(modifier = Modifier.fillMaxWidth()) { - FillWidth() - UnitButton( - onClick = { amountInputViewModel.switchUnit(currencies) }, - color = Colors.Brand, - modifier = Modifier.testTag("PaymentRequestAmountUnit"), + if (conversionError) { + BodyS( + text = stringResource(R.string.wallet__payment_request_rate_unavailable), + color = Colors.White64 ) } + FillHeight(min = 12.dp) + if (asset == PaykitAsset.BTC) { + Row(modifier = Modifier.fillMaxWidth()) { + FillWidth() + UnitButton( + onClick = { amountInputViewModel.switchUnit(currencies) }, + color = Colors.Brand, + modifier = Modifier.testTag("PaymentRequestAmountUnit") + ) + } + } VerticalSpacer(16.dp) HorizontalDivider(color = Colors.White10) - NumberPad( - viewModel = amountInputViewModel, - currencies = currencies, - availableHeight = availableHeight, - modifier = Modifier.testTag("PaymentRequestNumberPad"), - ) + if (asset == PaykitAsset.BTC) { + NumberPad( + viewModel = amountInputViewModel, + currencies = currencies, + availableHeight = availableHeight, + modifier = Modifier.testTag("PaymentRequestNumberPad") + ) + } else { + NumberPad( + onPress = { + dollars = NumberPadInputHandler.handleInput( + it, dollars, MAX_USD_INPUT_LENGTH, PaykitAsset.USD.decimals + ) + }, + type = NumberPadType.DECIMAL, + availableHeight = availableHeight, + modifier = Modifier.testTag("PaymentRequestNumberPad") + ) + } PrimaryButton( text = stringResource(R.string.common__continue), - enabled = amountState.sats > 0, + enabled = (entered?.atomic ?: 0uL) > 0uL, onClick = { - onContinue(initialDraft.copy(amountSats = amountState.sats.toULong())) + entered?.let { onContinue(initialDraft.copy(amount = it)) } }, modifier = Modifier.testTag("PaymentRequestAmountContinue"), ) @@ -204,6 +264,37 @@ internal fun PaymentRequestAmountContent( } } +private const val MAX_USD_INPUT_LENGTH = 18 + +@Composable +private fun PaymentRequestAssetSelector( + asset: PaykitAsset, + amount: PaykitAmount?, + onConverted: (PaykitAmount) -> Unit, + onUnavailable: () -> Unit, +) { + val currencies = LocalCurrencies.current + Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) { + listOf(PaykitAsset.BTC, PaykitAsset.USD).forEach { option -> + NumberPadActionButton( + text = option.code.uppercase(), + outlined = asset != option, + color = if (option == PaykitAsset.BTC) Colors.Brand else Colors.Green, + modifier = Modifier.testTag("PaymentRequestAsset${option.name}"), + onClick = { + if (option != asset) { + runCatching { + amount?.takeIf { it.atomic > 0uL }?.convertedTo( + option, currencies.paykitRate, Clock.System.now().toEpochMilliseconds() + ) ?: PaykitAmount(option, 0uL) + }.onSuccess(onConverted).onFailure { onUnavailable() } + } + }, + ) + } + } +} + @Composable fun PaymentRequestDetailsScreen( appViewModel: AppViewModel, @@ -215,11 +306,13 @@ fun PaymentRequestDetailsScreen( ) { val contacts by appViewModel.pubkyContacts.collectAsStateWithLifecycle() val isCreating by appViewModel.isCreatingPaymentRequest.collectAsStateWithLifecycle() + val receivingMethods by appViewModel.paykitReceivingMethods.collectAsStateWithLifecycle() val contact = contacts.firstOrNull { PubkyPublicKeyFormat.matches(it.publicKey, target.publicKey) } ?: PubkyProfile.placeholder(target.publicKey) PaymentRequestDetailsContent( initialDraft = draft, + availableMethods = receivingMethods, contact = contact, isCreating = isCreating, onBack = onBack, @@ -231,6 +324,7 @@ fun PaymentRequestDetailsScreen( @Composable internal fun PaymentRequestDetailsContent( initialDraft: PaykitPaymentRequestDraft, + availableMethods: List = emptyList(), contact: PubkyProfile, isCreating: Boolean, onBack: () -> Unit, @@ -238,11 +332,16 @@ internal fun PaymentRequestDetailsContent( onSend: (PaykitPaymentRequestDraft) -> Unit, modifier: Modifier = Modifier, ) { + var acceptedMethods by remember(initialDraft.acceptedPaymentEndpointIdentifiers) { + mutableStateOf(initialDraft.acceptedPaymentEndpointIdentifiers) + } + val selectedMethods = acceptedMethods ?: availableMethods var note by remember(initialDraft.note) { mutableStateOf(initialDraft.note) } var expiration by remember(initialDraft.expiresAt) { mutableStateOf(PaymentRequestExpiration.from(initialDraft.expiresAt, Clock.System.now())) } fun updatedDraft(trimNote: Boolean = false) = initialDraft.copy( + acceptedPaymentEndpointIdentifiers = selectedMethods, note = if (trimNote) note.trim() else note, expiresAt = Clock.System.now() + expiration.duration, ) @@ -259,22 +358,12 @@ internal fun PaymentRequestDetailsContent( titleText = stringResource(R.string.wallet__payment_request), onBack = onBack, ) - rememberMoneyText( - sats = initialDraft.amountSats.coerceAtMost(Long.MAX_VALUE.toULong()).toLong(), - reversed = true, - showSymbol = true, - )?.let { - Caption13Up(text = it.removeAccentTags(), color = Colors.White64) - } Row( verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp), modifier = Modifier.fillMaxWidth(), ) { - MoneyDisplay( - sats = initialDraft.amountSats.coerceAtMost(Long.MAX_VALUE.toULong()).toLong(), - showSymbol = true, - ) + PaykitAmountDisplay(initialDraft.amount) FillWidth() IconButton( onClick = { onEditAmount(updatedDraft()) }, @@ -303,6 +392,42 @@ internal fun PaymentRequestDetailsContent( .testTag("PaymentRequestNote"), ) VerticalSpacer(20.dp) + Caption13Up(text = stringResource(R.string.wallet__payment_request_accepted_methods), color = Colors.White64) + VerticalSpacer(8.dp) + Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) { + val groups = listOf( + MethodId.entries.filter { it.isOnchain }, + listOf(MethodId.Bolt11, MethodId.Lnurl), + listOf(MethodId.UsdtArbitrum), + ).map { methods -> methods.filter { it.rawValue in availableMethods } }.filter { it.isNotEmpty() } + groups.forEach { methods -> + val endpoints = methods.map { it.rawValue } + val selected = endpoints.all { it in selectedMethods } + val (label, color, id) = when (methods.first()) { + MethodId.UsdtArbitrum -> Triple("USDT", Colors.Green, "usdt") + MethodId.Bolt11, MethodId.Lnurl -> Triple( + stringResource(R.string.lightning__spending), + Colors.Purple, + "spending" + ) + else -> Triple(stringResource(R.string.lightning__savings), Colors.Brand, "savings") + } + NumberPadActionButton( + text = label, + color = color, + outlined = !selected, + onClick = { + acceptedMethods = if (selected) { + selectedMethods - endpoints.toSet() + } else { + selectedMethods + endpoints.filter { it !in selectedMethods } + } + }, + modifier = Modifier.testTag("PaymentRequestAccept-$id") + ) + } + } + VerticalSpacer(20.dp) Caption13Up(text = stringResource(R.string.wallet__payment_request_recipient), color = Colors.White64) VerticalSpacer(8.dp) Row( @@ -321,7 +446,7 @@ internal fun PaymentRequestDetailsContent( maxLines = 1, ) } - MoneyCell(sats = initialDraft.amountSats.coerceAtMost(Long.MAX_VALUE.toULong()).toLong()) + PaykitAmountCell(initialDraft.amount) } VerticalSpacer(20.dp) Caption13Up(text = stringResource(R.string.wallet__payment_request_expires), color = Colors.White64) @@ -348,7 +473,7 @@ internal fun PaymentRequestDetailsContent( FillHeight() PrimaryButton( text = stringResource(R.string.wallet__payment_request_send_request), - enabled = !isCreating, + enabled = !isCreating && selectedMethods.isNotEmpty(), isLoading = isCreating, onClick = { onSend(updatedDraft(trimNote = true)) }, icon = { @@ -590,7 +715,7 @@ internal fun PaymentRequestExpiration.title(): String = stringResource( ) private val previewDraft = PaykitPaymentRequestDraft( - amountSats = 25_000uL, + amount = PaykitAmount(PaykitAsset.BTC, 25_000uL), note = "Dinner", expiresAt = Instant.parse("2027-01-15T09:00:00Z"), ) @@ -602,8 +727,8 @@ private val previewTarget = PaykitPaymentRequestTarget( private val previewCreatedRequest = PaykitPaymentRequest( paymentRequestId = "payment-request", counterparty = previewTarget.publicKey, - amountValue = "0.00025", - amountSats = previewDraft.amountSats, + amount = previewDraft.amount, + paymentReference = "preview", note = previewDraft.note, createdAt = Instant.parse("2027-01-15T08:00:00Z"), expiresAt = previewDraft.expiresAt, diff --git a/app/src/main/java/to/bitkit/ui/screens/paymentrequests/IncomingPaymentRequestDetailsScreen.kt b/app/src/main/java/to/bitkit/ui/screens/paymentrequests/IncomingPaymentRequestDetailsScreen.kt index 46411d7fa6..bdcf470695 100644 --- a/app/src/main/java/to/bitkit/ui/screens/paymentrequests/IncomingPaymentRequestDetailsScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/paymentrequests/IncomingPaymentRequestDetailsScreen.kt @@ -43,15 +43,16 @@ import to.bitkit.models.PubkyPublicKeyFormat import to.bitkit.repositories.PaykitPaymentRequest import to.bitkit.repositories.PaykitPaymentRequestDirection import to.bitkit.repositories.PaykitPaymentRequestId +import to.bitkit.repositories.PaykitUsdtReceipt import to.bitkit.ui.components.AddTagButton import to.bitkit.ui.components.AddTagSheet import to.bitkit.ui.components.BodyM import to.bitkit.ui.components.BodyMSB import to.bitkit.ui.components.BodySSB import to.bitkit.ui.components.Caption13Up -import to.bitkit.ui.components.Display import to.bitkit.ui.components.FillHeight import to.bitkit.ui.components.FillWidth +import to.bitkit.ui.components.PaykitAmountDisplay import to.bitkit.ui.components.PrimaryButton import to.bitkit.ui.components.PubkyContactAvatar import to.bitkit.ui.components.SecondaryButton @@ -59,14 +60,11 @@ import to.bitkit.ui.components.TagButton import to.bitkit.ui.components.Title import to.bitkit.ui.components.VerticalSpacer import to.bitkit.ui.components.ZigzagDivider -import to.bitkit.ui.components.rememberMoneyText import to.bitkit.ui.scaffold.AppTopBar import to.bitkit.ui.scaffold.DrawerNavIcon import to.bitkit.ui.screens.wallets.activity.components.CircularIcon import to.bitkit.ui.theme.Colors -import to.bitkit.ui.utils.removeAccentTags import to.bitkit.ui.utils.uiDateText -import to.bitkit.ui.utils.withAccent import to.bitkit.viewmodels.AppViewModel import kotlin.time.ExperimentalTime @@ -77,6 +75,7 @@ fun IncomingPaymentRequestDetailsScreen( onBack: () -> Unit, ) { val pending by appViewModel.pendingPaymentRequests.collectAsStateWithLifecycle() + val receipts by appViewModel.paykitUsdtPayments.receipts.collectAsStateWithLifecycle() val history by appViewModel.paymentRequestHistory.collectAsStateWithLifecycle() val contacts by appViewModel.pubkyContacts.collectAsStateWithLifecycle() val requestedPaymentRequestId by appViewModel.requestedPaymentRequestId.collectAsStateWithLifecycle() @@ -89,6 +88,7 @@ fun IncomingPaymentRequestDetailsScreen( IncomingPaymentRequestDetailsContent( request = request, + receipt = receipts.lastOrNull { it.requestId == id }, contact = contact, isPending = isPending, isPreparing = requestedPaymentRequestId == id, @@ -101,6 +101,7 @@ fun IncomingPaymentRequestDetailsScreen( @Composable internal fun IncomingPaymentRequestDetailsContent( request: PaykitPaymentRequest?, + receipt: PaykitUsdtReceipt? = null, contact: PubkyProfile?, isPending: Boolean, isPreparing: Boolean, @@ -143,29 +144,19 @@ internal fun IncomingPaymentRequestDetailsContent( .padding(horizontal = 16.dp), ) { VerticalSpacer(16.dp) - rememberMoneyText( - sats = request.amountSats.coerceAtMost(Long.MAX_VALUE.toULong()).toLong(), - reversed = true, - showSymbol = true, - )?.let { - Caption13Up(text = it.removeAccentTags(), color = Colors.White64) - } - rememberMoneyText( - sats = request.amountSats.coerceAtMost(Long.MAX_VALUE.toULong()).toLong(), - )?.let { - Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) { - Display( - text = request.detailsAmountText(it).withAccent(accentColor = Colors.White64), - modifier = Modifier.testTag("PaymentRequestDetailsAmount") - ) - FillWidth() - if (request.hasPaymentEvidence) { - PaymentRequestDetailsIcon(request) - } else { - PubkyContactAvatar(profile = contact, size = 48.dp) - } + Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) { + PaykitAmountDisplay(request.amount, prefix = request.detailsAmountPrefix()) + FillWidth() + if (request.hasPaymentEvidence) { + PaymentRequestDetailsIcon(request) + } else { + PubkyContactAvatar(profile = contact, size = 48.dp) } } + receipt?.let { + VerticalSpacer(8.dp) + BodyM(text = paykitUsdtReceiptText(it), color = Colors.White64) + } BodyM( text = paymentRequestStatus(request, isPending = isPending), color = Colors.White64, diff --git a/app/src/main/java/to/bitkit/ui/screens/paymentrequests/PaymentRequestsScreen.kt b/app/src/main/java/to/bitkit/ui/screens/paymentrequests/PaymentRequestsScreen.kt index e1216b18d0..2c740593d0 100644 --- a/app/src/main/java/to/bitkit/ui/screens/paymentrequests/PaymentRequestsScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/paymentrequests/PaymentRequestsScreen.kt @@ -54,6 +54,8 @@ import kotlinx.collections.immutable.toImmutableSet import kotlinx.coroutines.launch import to.bitkit.R import to.bitkit.ext.UiDateStyle +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset import to.bitkit.models.PubkyProfile import to.bitkit.models.PubkyPublicKeyFormat import to.bitkit.repositories.PaykitPaymentProofKind @@ -62,6 +64,7 @@ import to.bitkit.repositories.PaykitPaymentRequestDeliveryStatus import to.bitkit.repositories.PaykitPaymentRequestDirection import to.bitkit.repositories.PaykitPaymentRequestId import to.bitkit.repositories.PaykitSubscription +import to.bitkit.repositories.PaykitUsdtReceipt import to.bitkit.ui.components.BodyM import to.bitkit.ui.components.BodyMSB import to.bitkit.ui.components.BodyS @@ -70,7 +73,7 @@ import to.bitkit.ui.components.ButtonSize import to.bitkit.ui.components.Caption13Up import to.bitkit.ui.components.Display import to.bitkit.ui.components.FillHeight -import to.bitkit.ui.components.MoneyCell +import to.bitkit.ui.components.PaykitAmountCell import to.bitkit.ui.components.PrimaryButton import to.bitkit.ui.components.PubkyContactAvatar import to.bitkit.ui.components.SecondaryButton @@ -199,6 +202,7 @@ fun PaymentRequestsScreen( topPadding: Dp = 0.dp, ) { val pending by appViewModel.pendingPaymentRequests.collectAsStateWithLifecycle() + val receipts by appViewModel.paykitUsdtPayments.receipts.collectAsStateWithLifecycle() val history by appViewModel.paymentRequestHistory.collectAsStateWithLifecycle() val contacts by appViewModel.pubkyContacts.collectAsStateWithLifecycle() val targets by appViewModel.eligiblePaymentRequestTargets.collectAsStateWithLifecycle() @@ -208,6 +212,7 @@ fun PaymentRequestsScreen( PaymentRequestsContent( requests = (pending + history).distinctBy { it.id }.toImmutableList(), pending = pending.toImmutableList(), + receipts = receipts.toImmutableList(), contacts = contacts.toImmutableList(), subscriptions = subscriptions.toImmutableList(), dismissingRequestIds = dismissingRequestIds.toImmutableSet(), @@ -224,6 +229,7 @@ fun PaymentRequestsScreen( @Composable internal fun PaymentRequestsContent( + receipts: ImmutableList = persistentListOf(), modifier: Modifier = Modifier, requests: ImmutableList, pending: ImmutableList, @@ -338,6 +344,7 @@ internal fun PaymentRequestsContent( paymentRequestStatus(request) }, showSignedAmount = request.hasPaymentEvidence, + receipt = receipts.lastOrNull { it.requestId == request.id }, onClick = { onDetails(request.id) }, ) } @@ -514,6 +521,20 @@ internal fun proposedPaymentRequestStatusRes(request: PaykitPaymentRequest, isPe else -> R.string.wallet__payment_request_sending } +@Composable +private fun paymentRequestAmountStatus( + request: PaykitPaymentRequest, + receipt: PaykitUsdtReceipt?, + fiatStatus: String?, +): String? = receipt?.let { paykitUsdtReceiptText(it) } ?: fiatStatus + ?: if (request.direction == PaykitPaymentRequestDirection.Outgoing && + request.paymentProofKind == PaykitPaymentProofKind.Usdt + ) { + stringResource(R.string.wallet__payment_request_pending) + } else { + null + } + @Composable internal fun PaymentRequestCard( request: PaykitPaymentRequest, @@ -524,6 +545,7 @@ internal fun PaymentRequestCard( showSignedAmount: Boolean = false, showBitcoinSymbol: Boolean = true, fiatStatus: String? = null, + receipt: PaykitUsdtReceipt? = null, onClick: (() -> Unit)? = null, isDismissing: Boolean = false, onPay: (() -> Unit)? = null, @@ -581,11 +603,11 @@ internal fun PaymentRequestCard( overflow = TextOverflow.Ellipsis, ) } - MoneyCell( - sats = request.amountSats.coerceAtMost(Long.MAX_VALUE.toULong()).toLong(), + PaykitAmountCell( + amount = request.amount, prefix = amountPrefix, showBitcoinSymbol = showBitcoinSymbol, - fiatReplacement = fiatStatus, + status = paymentRequestAmountStatus(request, receipt, fiatStatus), ) } if (onPay != null || onDismiss != null) { @@ -692,8 +714,8 @@ private fun PaymentRailIcon(request: PaykitPaymentRequest, paymentWasSent: Boole private val previewRequest = PaykitPaymentRequest( paymentRequestId = "payment-request", counterparty = "pubky3rsduhcxpw74snwyct86m38c63j3pq8x4ycqikxg64roik8yw5xg", - amountValue = "0.00025", - amountSats = 25_000uL, + amount = PaykitAmount(PaykitAsset.BTC, 25_000uL), + paymentReference = "preview", note = "Dinner", createdAt = Instant.parse("2027-01-15T08:00:00Z"), expiresAt = Instant.parse("2027-01-15T09:00:00Z"), @@ -745,3 +767,14 @@ private fun PaymentRequestsPreview() { ) } } + +@Composable +internal fun paykitUsdtReceiptText(receipt: PaykitUsdtReceipt): String { + val label = when { + !receipt.verified -> R.string.wallet__payment_request_pending + receipt.underpaid -> R.string.wallet__payment_request_underpaid + receipt.afterExpiry -> R.string.wallet__payment_request_after_expiry + else -> R.string.wallet__payment_request_payment_verified + } + return stringResource(label) + " · " + receipt.amount.value + " USDT" +} diff --git a/app/src/main/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalSheet.kt b/app/src/main/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalSheet.kt index 58afffee44..5bcc774d4b 100644 --- a/app/src/main/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalSheet.kt +++ b/app/src/main/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalSheet.kt @@ -2,6 +2,7 @@ package to.bitkit.ui.screens.profile import androidx.compose.foundation.Image import androidx.compose.foundation.background +import androidx.compose.foundation.clickable import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.BoxWithConstraints @@ -68,11 +69,15 @@ import to.bitkit.ui.shared.modifiers.sheetHeight import to.bitkit.ui.shared.util.gradientBackground import to.bitkit.ui.theme.AppThemeSurface import to.bitkit.ui.theme.Colors +import to.bitkit.ui.utils.copyToClipboard import to.bitkit.ui.utils.rememberBiometricAuthSupported import to.bitkit.ui.utils.removeAccentTags import to.bitkit.ui.utils.withAccent import to.bitkit.ui.utils.withAccentBoldBright +private const val ADDRESS_PREFIX_LENGTH = 8 +private const val ADDRESS_SUFFIX_LENGTH = 6 + @Composable fun PubkyAuthApprovalSheet( authUrl: String, @@ -100,6 +105,7 @@ fun PubkyAuthApprovalSheet( onBackToWatchOnly = { if (uiState.authUrl == authUrl) viewModel.returnToWatchOnlyConsent(authUrl) }, + onRetryUsdt = { viewModel.loadUsdtAddress(authUrl) }, onCancel = { viewModel.dismiss() }, onDismiss = { viewModel.dismiss() }, ) @@ -214,6 +220,7 @@ private fun Content( onBackToWatchOnly: () -> Unit, onCancel: () -> Unit, onDismiss: () -> Unit, + onRetryUsdt: () -> Unit = {}, ) { val approvalState = if (isCurrentRequest) uiState.state else ApprovalState.Loading val headerTitle = approvalHeaderTitle(approvalState) @@ -237,12 +244,14 @@ private fun Content( when (approvalState) { ApprovalState.Loading -> LoadingContent() ApprovalState.WatchOnlyConsent -> WatchOnlyConsentContent( + claim = uiState.bitkitClaim, onApprove = onApproveWatchOnly, onCancel = onCancel, ) ApprovalState.Authorize -> AuthorizeContent( uiState = uiState, onAuthorize = onAuthorize, + onRetryUsdt = onRetryUsdt, onCancel = onCancel, ) ApprovalState.Authenticating, ApprovalState.Authorizing -> AuthorizingContent( @@ -270,7 +279,7 @@ private fun approvalBackAction( onCancel: () -> Unit, onDismiss: () -> Unit, ): (() -> Unit)? = when (approvalState) { - ApprovalState.Authorize if bitkitClaim?.includesWatchOnlyAccount == true -> onBackToWatchOnly + ApprovalState.Authorize if bitkitClaim?.sharesReceivingDetails == true -> onBackToWatchOnly ApprovalState.Authorize, ApprovalState.Authenticating, ApprovalState.Authorizing -> onCancel ApprovalState.Success -> onDismiss else -> null @@ -278,6 +287,7 @@ private fun approvalBackAction( @Composable private fun ColumnScope.WatchOnlyConsentContent( + claim: PubkyAuthClaim?, onApprove: () -> Unit, onCancel: () -> Unit, ) { @@ -304,12 +314,26 @@ private fun ColumnScope.WatchOnlyConsentContent( VerticalSpacer(32.dp) Display( - text = stringResource(R.string.profile__auth_approval_watch_only_intro_title) - .withAccent(accentColor = Colors.Blue), + text = stringResource( + when (claim) { + PubkyAuthClaim.USDT_ADDRESS_V1 -> R.string.profile__auth_approval_usdt_intro_title + PubkyAuthClaim.PAYMENT_DETAILS_V1 -> R.string.profile__auth_approval_payment_details_intro_title + else -> R.string.profile__auth_approval_watch_only_intro_title + } + ).withAccent( + accentColor = if (claim == PubkyAuthClaim.USDT_ADDRESS_V1) Colors.Green else Colors.Blue + ), ) VerticalSpacer(8.dp) BodyM( - text = stringResource(R.string.profile__auth_approval_watch_only_intro_description), + text = stringResource( + when (claim) { + PubkyAuthClaim.USDT_ADDRESS_V1 -> R.string.profile__auth_approval_usdt_intro_description + PubkyAuthClaim.PAYMENT_DETAILS_V1 -> + R.string.profile__auth_approval_payment_details_intro_description + else -> R.string.profile__auth_approval_watch_only_intro_description + } + ), color = Colors.White64, ) @@ -350,10 +374,11 @@ private fun ColumnScope.LoadingContent() { @Composable private fun ColumnScope.AuthorizeContent( uiState: PubkyAuthApprovalUiState, + onRetryUsdt: () -> Unit, onAuthorize: () -> Unit, onCancel: () -> Unit, ) { - ApprovalDetails(uiState = uiState) + ApprovalDetails(uiState = uiState, onRetryUsdt = onRetryUsdt) Row(horizontalArrangement = Arrangement.spacedBy(16.dp)) { SecondaryButton( @@ -364,6 +389,7 @@ private fun ColumnScope.AuthorizeContent( PrimaryButton( text = stringResource(R.string.profile__auth_approval_authorize), onClick = onAuthorize, + enabled = uiState.canAuthorize, modifier = Modifier .weight(1f) .testTag("PubkyAuthAuthorize") @@ -395,6 +421,7 @@ private fun ColumnScope.AuthorizingContent( @Composable private fun ColumnScope.ApprovalDetails( uiState: PubkyAuthApprovalUiState, + onRetryUsdt: (() -> Unit)? = null, ) { BoxWithConstraints(modifier = Modifier.weight(1f)) { Column( @@ -413,6 +440,12 @@ private fun ColumnScope.ApprovalDetails( if (uiState.permissions.isNotEmpty()) { DescriptionText(clientId = uiState.clientId, serviceName = uiState.serviceName) VerticalSpacer(32.dp) + } + if (uiState.bitkitClaim?.sharesReceivingDetails == true) { + PaymentDetailsSection(uiState, onRetryUsdt) + VerticalSpacer(24.dp) + } + if (uiState.permissions.isNotEmpty()) { PermissionsSection(permissions = uiState.permissions) } if (uiState.bitkitClaim?.includesPaykitAccess == true) { @@ -475,6 +508,18 @@ private fun ColumnScope.SuccessContent( modifier = Modifier.padding(horizontal = 16.dp, vertical = 16.dp) ) + uiState.bitkitClaim?.takeIf { it.sharesReceivingDetails }?.let { claim -> + BodyM( + text = stringResource( + when (claim) { + PubkyAuthClaim.USDT_ADDRESS_V1 -> R.string.profile__auth_approval_shared_usdt + PubkyAuthClaim.PAYMENT_DETAILS_V1 -> R.string.profile__auth_approval_shared_both + else -> R.string.profile__auth_approval_shared_bitcoin + } + ), + modifier = Modifier.testTag("PubkyAuthSharedDetails") + ) + } Image( painter = painterResource(R.drawable.check), contentDescription = null, @@ -498,6 +543,68 @@ private fun ColumnScope.SuccessContent( VerticalSpacer(16.dp) } +@Composable +private fun PaymentDetailsSection(uiState: PubkyAuthApprovalUiState, onRetryUsdt: (() -> Unit)?) { + Text13Up(text = stringResource(R.string.profile__auth_approval_payment_details), color = Colors.White64) + VerticalSpacer(12.dp) + if (uiState.bitkitClaim?.sharesBitcoin == true) { + Column(modifier = Modifier.testTag("PubkyAuthBitcoinDetails")) { + BodySSB(text = "Bitcoin", color = Colors.Brand) + VerticalSpacer(4.dp) + BodyS(text = stringResource(R.string.profile__auth_approval_bitcoin_account), color = Colors.White64) + } + VerticalSpacer(12.dp) + } + if (uiState.bitkitClaim?.sharesUsdt == true) { + Column(modifier = Modifier.testTag("PubkyAuthUsdtDetails")) { + BodySSB(text = "USDT · Arbitrum One", color = Colors.Green) + VerticalSpacer(8.dp) + uiState.usdtAddress?.let { address -> + var expanded by remember(address) { mutableStateOf(false) } + BodyS( + text = if (expanded) { + address + } else { + address.take(ADDRESS_PREFIX_LENGTH) + "…" + address.takeLast(ADDRESS_SUFFIX_LENGTH) + }, + modifier = Modifier.clickable { expanded = !expanded }.testTag("PubkyAuthUsdtAddress") + ) + if (expanded) { + VerticalSpacer(8.dp) + BodySSB( + text = stringResource(R.string.common__copy), + color = Colors.Green, + modifier = Modifier + .clickable(onClick = copyToClipboard(address)) + .testTag("PubkyAuthCopyUsdtAddress") + ) + } + } ?: BodyS( + text = stringResource( + if (uiState.usdtUnavailable) { + R.string.profile__auth_approval_usdt_unavailable + } else { + R.string.profile__auth_approval_usdt_loading + } + ), + color = Colors.White64, + ) + if (uiState.usdtUnavailable && onRetryUsdt != null) { + VerticalSpacer(8.dp) + BodySSB( + text = stringResource(R.string.common__retry), + color = Colors.Green, + modifier = Modifier.clickable(onClick = onRetryUsdt) + ) + } + VerticalSpacer(8.dp) + BodyS(text = stringResource(R.string.profile__auth_approval_usdt_privacy), color = Colors.White64) + } + VerticalSpacer(12.dp) + } + HorizontalDivider(color = Colors.White10) +} + @Composable private fun DescriptionText(clientId: String, serviceName: String) { val requester = clientId.asLiteralRequestText() diff --git a/app/src/main/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalViewModel.kt b/app/src/main/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalViewModel.kt index 47ad67e380..5ecc609fdd 100644 --- a/app/src/main/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalViewModel.kt +++ b/app/src/main/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalViewModel.kt @@ -25,8 +25,10 @@ import to.bitkit.models.PubkyAuthRequestError import to.bitkit.models.PubkyProfile import to.bitkit.models.Toast import to.bitkit.models.WatchOnlyAccountSetupState +import to.bitkit.repositories.Endpoint import to.bitkit.repositories.PubkyAlreadySignedInError import to.bitkit.repositories.PubkyRepo +import to.bitkit.repositories.UsdtRepo import to.bitkit.repositories.WatchOnlyAccountAuthorizationStartError import to.bitkit.repositories.WatchOnlyAccountRepo import to.bitkit.ui.shared.toast.ToastEventBus @@ -40,6 +42,7 @@ class PubkyAuthApprovalViewModel @Inject constructor( @ApplicationContext private val context: Context, private val pubkyRepo: PubkyRepo, private val watchOnlyAccountRepo: WatchOnlyAccountRepo, + private val usdtRepo: UsdtRepo, ) : ViewModel() { companion object { private const val TAG = "PubkyAuthApprovalVM" @@ -79,7 +82,7 @@ class PubkyAuthApprovalViewModel @Inject constructor( val serviceName = request.serviceNames.firstOrNull() ?: unknownService _uiState.update { it.copy( - state = if (request.bitkitClaim?.includesWatchOnlyAccount == true) { + state = if (request.bitkitClaim?.sharesReceivingDetails == true) { ApprovalState.WatchOnlyConsent } else { ApprovalState.Authorize @@ -93,12 +96,24 @@ class PubkyAuthApprovalViewModel @Inject constructor( profile = approvalProfile(), ) } + loadUsdtAddress(authUrl) + } + } + + fun loadUsdtAddress(authUrl: String) { + if (_uiState.value.authUrl != authUrl || _uiState.value.bitkitClaim?.sharesUsdt != true) return + _uiState.update { it.copy(usdtAddress = null, usdtUnavailable = false) } + viewModelScope.launch { + val address = usdtRepo.paymentEndpoint().getOrNull()?.value + _uiState.update { + if (it.authUrl == authUrl) it.copy(usdtAddress = address, usdtUnavailable = address == null) else it + } } } fun requestAuthorize(authUrl: String) { val state = _uiState.value - if (state.authUrl != authUrl || state.state != ApprovalState.Authorize) return + if (state.authUrl != authUrl || state.state != ApprovalState.Authorize || !state.canAuthorize) return if (!_uiState.compareAndSet(state, state.copy(state = ApprovalState.Authenticating))) return viewModelScope.launch { _effects.emit(PubkyAuthApprovalEffect.RequestLocalAuth(authUrl)) @@ -120,7 +135,7 @@ class PubkyAuthApprovalViewModel @Inject constructor( if ( state.authUrl == authUrl && state.state == ApprovalState.Authorize && - state.bitkitClaim?.includesWatchOnlyAccount == true + state.bitkitClaim?.sharesReceivingDetails == true ) { state.copy(state = ApprovalState.WatchOnlyConsent) } else { @@ -203,8 +218,15 @@ class PubkyAuthApprovalViewModel @Inject constructor( request: PubkyAuthRequest, authUrl: String, ): Boolean { + val endpoint = runSuspendCatching { + validatedUsdtEndpoint(request) + }.getOrElse { + handleApprovalFailure(it, authUrl) + loadUsdtAddress(authUrl) + return false + } val preparedClaim = runSuspendCatching { - if (request.bitkitClaim?.includesWatchOnlyAccount == true) { + if (request.bitkitClaim?.sharesBitcoin == true) { watchOnlyAccountRepo.prepareUnsignedClaim(authUrl, defaultWatchOnlyAccountName(request)) } else { null @@ -228,10 +250,11 @@ class PubkyAuthApprovalViewModel @Inject constructor( } } - val approvalResult = if (request.bitkitClaim != null) { - pubkyRepo.approveAuthWithCompanionClaim(authUrl, request.clientId, preparedClaim?.payload ?: byteArrayOf()) - } else { - pubkyRepo.approveAuth(authUrl, request.capabilities, request.clientId) + val approvalResult = runSuspendCatching { + request.bitkitClaim?.let { claimType -> + val payload = claimType.unsignedPayload(preparedClaim, endpoint) + pubkyRepo.approveAuthWithCompanionClaim(authUrl, request.clientId, payload).getOrThrow() + } ?: pubkyRepo.approveAuth(authUrl, request.capabilities, request.clientId).getOrThrow() } if (approvalResult.isFailure) { val approvalError = checkNotNull(approvalResult.exceptionOrNull()) { "Authorization failed" } @@ -247,13 +270,16 @@ class PubkyAuthApprovalViewModel @Inject constructor( return false } - preparedClaim?.let { claim -> - runSuspendCatching { watchOnlyAccountRepo.markActive(claim.account.id) }.getOrElse { - handleApprovalFailure(it, authUrl) - return false - } + return runSuspendCatching { + preparedClaim?.let { watchOnlyAccountRepo.markActive(it.account.id) } + }.onFailure { handleApprovalFailure(it, authUrl) }.isSuccess + } + + private suspend fun validatedUsdtEndpoint(request: PubkyAuthRequest): Endpoint? { + if (request.bitkitClaim?.sharesUsdt != true) return null + return usdtRepo.paymentEndpoint().getOrThrow().also { + if (it.value != _uiState.value.usdtAddress) throw PubkyAuthRequestError.InvalidPaymentDetails } - return true } private fun transitionToAuthorizing(authUrl: String): PubkyAuthApprovalUiState? { @@ -348,7 +374,11 @@ data class PubkyAuthApprovalUiState( val permissions: ImmutableList = persistentListOf(), val bitkitClaim: PubkyAuthClaim? = null, val profile: PubkyProfile? = null, -) + val usdtAddress: String? = null, + val usdtUnavailable: Boolean = false, +) { + val canAuthorize: Boolean get() = bitkitClaim?.sharesUsdt != true || usdtAddress != null +} sealed interface ApprovalState { data object Loading : ApprovalState diff --git a/app/src/main/java/to/bitkit/ui/screens/scanner/CameraPermissionView.kt b/app/src/main/java/to/bitkit/ui/screens/scanner/CameraPermissionView.kt index 84f05f180e..d6fb1ef8d2 100644 --- a/app/src/main/java/to/bitkit/ui/screens/scanner/CameraPermissionView.kt +++ b/app/src/main/java/to/bitkit/ui/screens/scanner/CameraPermissionView.kt @@ -56,7 +56,7 @@ fun CameraPermissionView( @Composable fun DeniedContent( onClickRetry: () -> Unit = {}, - onClickPaste: () -> Unit = {}, + onClickPaste: (() -> Unit)? = {}, ) { Column( horizontalAlignment = Alignment.CenterHorizontally, @@ -103,16 +103,18 @@ fun DeniedContent( FillHeight() - PrimaryButton( - text = stringResource(R.string.other__qr_paste), - icon = { - Icon( - painter = painterResource(R.drawable.ic_clipboard_text_simple), - contentDescription = null, - ) - }, - onClick = onClickPaste, - ) + if (onClickPaste != null) { + PrimaryButton( + text = stringResource(R.string.other__qr_paste), + icon = { + Icon( + painter = painterResource(R.drawable.ic_clipboard_text_simple), + contentDescription = null, + ) + }, + onClick = onClickPaste, + ) + } } } diff --git a/app/src/main/java/to/bitkit/ui/screens/subscriptions/CreateSubscriptionScreen.kt b/app/src/main/java/to/bitkit/ui/screens/subscriptions/CreateSubscriptionScreen.kt index c7b04259c7..b13bc959f3 100644 --- a/app/src/main/java/to/bitkit/ui/screens/subscriptions/CreateSubscriptionScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/subscriptions/CreateSubscriptionScreen.kt @@ -49,6 +49,7 @@ import androidx.hilt.navigation.compose.hiltViewModel import androidx.lifecycle.compose.collectAsStateWithLifecycle import coil3.compose.AsyncImage import kotlinx.collections.immutable.ImmutableList +import kotlinx.collections.immutable.persistentListOf import kotlinx.collections.immutable.toImmutableList import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.launch @@ -56,9 +57,13 @@ import kotlinx.coroutines.withContext import to.bitkit.R import to.bitkit.ext.getClipboardText import to.bitkit.ext.runSuspendCatching +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset +import to.bitkit.models.PaykitRequestPricing import to.bitkit.models.PubkyProfile import to.bitkit.models.PubkyPublicKeyFormat import to.bitkit.models.Toast +import to.bitkit.repositories.MethodId import to.bitkit.repositories.PaykitPaymentRequestDeliveryStatus import to.bitkit.repositories.PaykitPaymentRequestDraft import to.bitkit.repositories.PaykitPaymentRequestTarget @@ -66,11 +71,12 @@ import to.bitkit.repositories.PaykitRecurrenceUnit import to.bitkit.repositories.PaykitSubscription import to.bitkit.repositories.PaykitSubscriptionDraft import to.bitkit.ui.components.BodyM +import to.bitkit.ui.components.BodyMSB import to.bitkit.ui.components.BottomSheetPreview import to.bitkit.ui.components.Caption13Up import to.bitkit.ui.components.CaptionB import to.bitkit.ui.components.Display -import to.bitkit.ui.components.MoneyDisplay +import to.bitkit.ui.components.PaykitAmountDisplay import to.bitkit.ui.components.PrimaryButton import to.bitkit.ui.components.PubkyContactRow import to.bitkit.ui.components.TextInput @@ -104,8 +110,9 @@ fun CreateSubscriptionSheet( val contacts by appViewModel.pubkyContacts.collectAsStateWithLifecycle() val targets by appViewModel.eligiblePaymentRequestTargets.collectAsStateWithLifecycle() val isCreating by appViewModel.isCreatingPaymentRequest.collectAsStateWithLifecycle() + val receivingMethods by appViewModel.paykitReceivingMethods.collectAsStateWithLifecycle() var step by remember { mutableStateOf(SubscriptionCreationStep.Details) } - var amountSats by remember { mutableStateOf(0uL) } + var amount by remember { mutableStateOf(PaykitAmount(PaykitAsset.BTC, 0uL)) } var name by remember { mutableStateOf("") } var description by remember { mutableStateOf("") } var frequency by remember { mutableStateOf(PaykitRecurrenceUnit.Month) } @@ -118,7 +125,11 @@ fun CreateSubscriptionSheet( when (step) { SubscriptionCreationStep.Details -> CreateSubscriptionDetails( - amountSats = amountSats, + amount = amount, + acceptedMethods = PaykitRequestPricing.subscriptionEndpoints( + amount.asset, + receivingMethods, + ).toImmutableList(), name = name, description = description, frequency = frequency, @@ -153,14 +164,14 @@ fun CreateSubscriptionSheet( SubscriptionCreationStep.Amount -> PaymentRequestAmountContent( amountInputViewModel = amountInputViewModel, initialDraft = PaykitPaymentRequestDraft( - amountSats = amountSats, + amount = amount, note = name, expiresAt = SubscriptionClockOffset.subscriptionNow() + expiration.duration, ), contact = null, onBack = { step = SubscriptionCreationStep.Details }, onContinue = { - amountSats = it.amountSats + amount = it.amount step = SubscriptionCreationStep.Details }, modifier = Modifier.sheetHeight() @@ -180,7 +191,7 @@ fun CreateSubscriptionSheet( selectedTarget?.let { target -> appViewModel.createSubscription( draft = PaykitSubscriptionDraft( - amountSats = amountSats, + amount = amount, name = name, description = description, frequency = frequency, @@ -210,7 +221,8 @@ fun CreateSubscriptionSheet( @Composable internal fun CreateSubscriptionDetails( - amountSats: ULong, + amount: PaykitAmount, + acceptedMethods: ImmutableList, name: String, description: String, frequency: PaykitRecurrenceUnit, @@ -257,11 +269,7 @@ internal fun CreateSubscriptionDetails( horizontalArrangement = Arrangement.spacedBy(8.dp), modifier = Modifier.fillMaxWidth().clickableAlpha(onClick = onAmountClick) ) { - MoneyDisplay( - sats = amountSats.coerceAtMost(Long.MAX_VALUE.toULong()).toLong(), - showSymbol = true, - modifier = Modifier.weight(1f, fill = false) - ) + PaykitAmountDisplay(amount) Icon( painter = painterResource(R.drawable.ic_pencil_simple), contentDescription = stringResource(R.string.common__edit), @@ -270,6 +278,31 @@ internal fun CreateSubscriptionDetails( ) } VerticalSpacer(24.dp) + Column(modifier = Modifier.testTag("SubscriptionAcceptedMethods")) { + Caption13Up( + text = stringResource(R.string.wallet__payment_request_accepted_methods), + color = Colors.White64, + ) + VerticalSpacer(8.dp) + Row(horizontalArrangement = Arrangement.spacedBy(16.dp)) { + if (MethodId.UsdtArbitrum.rawValue in acceptedMethods) { + BodyMSB(text = "USDT", color = Colors.Green) + } + if (acceptedMethods.any { MethodId.fromRawValue(it)?.isOnchain == true }) { + BodyMSB(text = stringResource(R.string.lightning__savings), color = Colors.Brand) + } + if (MethodId.Bolt11.rawValue in acceptedMethods) { + BodyMSB(text = stringResource(R.string.lightning__spending), color = Colors.Purple) + } + if (acceptedMethods.isEmpty()) { + BodyM( + text = stringResource(R.string.wallet__payment_request_status_unavailable), + color = Colors.White64, + ) + } + } + } + VerticalSpacer(24.dp) Caption13Up(text = stringResource(R.string.subscriptions__frequency), color = Colors.White64) VerticalSpacer(8.dp) SubscriptionFrequencyPicker(frequency, onFrequencyChange) @@ -329,7 +362,7 @@ internal fun CreateSubscriptionDetails( PrimaryButton( text = stringResource(R.string.subscriptions__choose_recipient), onClick = onChooseRecipient, - enabled = amountSats > 0uL && name.isNotBlank() && !isLoadingIcon, + enabled = amount.atomic > 0uL && name.isNotBlank() && !isLoadingIcon && acceptedMethods.isNotEmpty(), modifier = Modifier.testTag("SubscriptionChooseRecipient") ) VerticalSpacer(16.dp) @@ -541,7 +574,8 @@ private fun CreateSubscriptionDetailsPreview() { AppThemeSurface { BottomSheetPreview { CreateSubscriptionDetails( - amountSats = 100_000uL, + amount = PaykitAmount(PaykitAsset.BTC, 100_000uL), + acceptedMethods = persistentListOf(MethodId.P2wpkh.rawValue, MethodId.Bolt11.rawValue), name = "Rent Support", description = "Monthly support", frequency = PaykitRecurrenceUnit.Month, diff --git a/app/src/main/java/to/bitkit/ui/screens/subscriptions/SubscriptionRow.kt b/app/src/main/java/to/bitkit/ui/screens/subscriptions/SubscriptionRow.kt index a0136d8606..415cfba54a 100644 --- a/app/src/main/java/to/bitkit/ui/screens/subscriptions/SubscriptionRow.kt +++ b/app/src/main/java/to/bitkit/ui/screens/subscriptions/SubscriptionRow.kt @@ -24,7 +24,7 @@ import to.bitkit.models.PubkyProfile import to.bitkit.repositories.PaykitSubscription import to.bitkit.ui.components.BodyMSB import to.bitkit.ui.components.CaptionB -import to.bitkit.ui.components.MoneyCell +import to.bitkit.ui.components.PaykitAmountCell import to.bitkit.ui.components.PubkyContactAvatar import to.bitkit.ui.components.PubkyImage import to.bitkit.ui.shared.modifiers.clickableAlpha @@ -63,7 +63,7 @@ internal fun SubscriptionRow( overflow = TextOverflow.Ellipsis, ) } - MoneyCell(sats = subscription.displaySats) + PaykitAmountCell(subscription.amount) } } diff --git a/app/src/main/java/to/bitkit/ui/screens/subscriptions/SubscriptionsScreen.kt b/app/src/main/java/to/bitkit/ui/screens/subscriptions/SubscriptionsScreen.kt index ee8847c07d..3d02e4cccf 100644 --- a/app/src/main/java/to/bitkit/ui/screens/subscriptions/SubscriptionsScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/subscriptions/SubscriptionsScreen.kt @@ -66,6 +66,8 @@ import kotlinx.coroutines.launch import to.bitkit.R import to.bitkit.ext.dateTimeFormatterOf import to.bitkit.models.NewTransactionSheetType +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset import to.bitkit.models.PubkyProfile import to.bitkit.models.PubkyPublicKeyFormat import to.bitkit.repositories.PaykitPaymentRequestDeliveryStatus @@ -83,8 +85,8 @@ import to.bitkit.ui.components.Caption13Up import to.bitkit.ui.components.Display import to.bitkit.ui.components.FillHeight import to.bitkit.ui.components.FillWidth -import to.bitkit.ui.components.MoneyDisplay -import to.bitkit.ui.components.MoneyMSB +import to.bitkit.ui.components.PaykitAmountCell +import to.bitkit.ui.components.PaykitAmountDisplay import to.bitkit.ui.components.PrimaryButton import to.bitkit.ui.components.SecondaryButton import to.bitkit.ui.components.Sheet @@ -216,7 +218,7 @@ internal fun SubscriptionsContent( ) { item { SubscriptionMetrics( - monthlyCostSats = subscriptionMonthlyCostSats(subscriptions, now), + monthlyCosts = subscriptionMonthlyCosts(subscriptions, now), activeCount = sections.active.size, createdCount = sections.created.size, ) @@ -391,7 +393,7 @@ private fun SubscriptionEmptyState(modifier: Modifier = Modifier) { } @Composable -private fun SubscriptionMetrics(monthlyCostSats: Long, activeCount: Int, createdCount: Int) { +private fun SubscriptionMetrics(monthlyCosts: List, activeCount: Int, createdCount: Int) { Row( verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(16.dp), @@ -407,7 +409,7 @@ private fun SubscriptionMetrics(monthlyCostSats: Long, activeCount: Int, created tint = Colors.Purple, modifier = Modifier.size(24.dp) ) - MoneyMSB(sats = monthlyCostSats, showSymbol = true) + Column { monthlyCosts.forEach { PaykitAmountCell(it) } } } } VerticalDivider(color = Colors.White16, modifier = Modifier.height(50.dp)) @@ -439,6 +441,7 @@ fun SubscriptionDetailScreen( ) { val subscriptions by appViewModel.subscriptions.collectAsStateWithLifecycle() val contacts by appViewModel.pubkyContacts.collectAsStateWithLifecycle() + val receipts by appViewModel.paykitUsdtPayments.receipts.collectAsStateWithLifecycle() val paymentHistory by appViewModel.paymentRequestHistory.collectAsStateWithLifecycle() val subscription = subscriptions.firstOrNull { it.id == id } val now = rememberSubscriptionNow(listOfNotNull(subscription).toImmutableList()) @@ -476,7 +479,7 @@ fun SubscriptionDetailScreen( Column(verticalArrangement = Arrangement.spacedBy(16.dp), modifier = Modifier.fillMaxWidth()) { Caption13Up(text = subscription.cadenceText(), color = Colors.White64) Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) { - MoneyDisplay(sats = subscription.displaySats, showSymbol = true) + PaykitAmountDisplay(subscription.amount) FillWidth() SubscriptionAvatar( subscription = subscription, @@ -499,6 +502,7 @@ fun SubscriptionDetailScreen( payments.forEach { payment -> PaymentRequestCard( request = payment, + receipt = receipts.lastOrNull { it.requestId == payment.id }, contact = contacts.contactFor(subscription), title = subscription.note?.takeIf(String::isNotBlank) ?: stringResource(R.string.subscriptions__subscription), @@ -787,16 +791,18 @@ private fun SubscriptionReview( .padding(horizontal = 16.dp) ) { SheetTopBar(titleText = stringResource(R.string.subscriptions__review_and_subscribe)) - rememberMoneyText(sats = subscription.displaySats, reversed = true, showSymbol = true)?.let { - Caption13Up(text = it.removeAccentTags(), color = Colors.White64) + if (subscription.amount.asset == PaykitAsset.BTC) { + rememberMoneyText(sats = subscription.displaySats, reversed = true, showSymbol = true)?.let { + Caption13Up(text = it.removeAccentTags(), color = Colors.White64) + } } - MoneyDisplay(sats = subscription.displaySats, showSymbol = true) + PaykitAmountDisplay(subscription.amount) VerticalSpacer(24.dp) SubscriptionProviderCard(subscription, contact, onClick = onDetails, showAsCard = true) if (!subscription.recurrence.unit.isSupported) { VerticalSpacer(16.dp) BodyM(text = stringResource(R.string.subscriptions__unsupported_description), color = Colors.White64) - } else if (subscription.hasPaymentDeadline || subscription.acceptedPaymentEndpointIdentifiers.isEmpty()) { + } else if (subscription.acceptedPaymentEndpointIdentifiers.isEmpty()) { VerticalSpacer(16.dp) BodyM( text = stringResource(R.string.subscriptions__unsupported_payment_description), @@ -975,10 +981,12 @@ private fun SubscriptionCancel( } ) ) - rememberMoneyText(sats = subscription.displaySats, reversed = true, showSymbol = true)?.let { - Caption13Up(text = it.removeAccentTags(), color = Colors.White64) + if (subscription.amount.asset == PaykitAsset.BTC) { + rememberMoneyText(sats = subscription.displaySats, reversed = true, showSymbol = true)?.let { + Caption13Up(text = it.removeAccentTags(), color = Colors.White64) + } } - MoneyDisplay(sats = subscription.displaySats, showSymbol = true) + PaykitAmountDisplay(subscription.amount) VerticalSpacer(24.dp) SubscriptionProviderCard( subscription = subscription, @@ -1183,29 +1191,31 @@ private fun Instant.formatShortDate(): String = dateTimeFormatterOf("MMMM d") .format(java.time.Instant.ofEpochMilli(toEpochMilliseconds())) internal val PaykitSubscription.displaySats: Long - get() = amountSats.coerceAtMost(Long.MAX_VALUE.toULong()).toLong() + get() = amount.atomic.coerceAtMost(Long.MAX_VALUE.toULong()).toLong() -internal fun subscriptionMonthlyCostSats( +internal fun subscriptionMonthlyCosts( subscriptions: List, now: Instant, -): Long { - val running = subscriptions.filter { it.isPayer && it.runsUntilPaidThrough(now) } - val total = running.fold(BigDecimal.ZERO) { total, subscription -> - val annualPeriods = when (subscription.recurrence.unit) { - PaykitRecurrenceUnit.Minute -> 525_600L - PaykitRecurrenceUnit.Hour -> 8_760L - PaykitRecurrenceUnit.Day -> 365L - PaykitRecurrenceUnit.Week -> 52L - PaykitRecurrenceUnit.Month -> 12L - PaykitRecurrenceUnit.Year -> 1L +): List { + val active = subscriptions.filter { it.isPayer && it.runsUntilPaidThrough(now) } + val assets = active.map { it.amount.asset }.distinct().ifEmpty { listOf(PaykitAsset.BTC) } + return assets.sortedBy { it.code }.map { asset -> + val total = active.filter { it.amount.asset == asset }.fold(BigDecimal.ZERO) { total, subscription -> + val annualPeriods = when (subscription.recurrence.unit) { + PaykitRecurrenceUnit.Minute -> 525_600L + PaykitRecurrenceUnit.Hour -> 8_760L + PaykitRecurrenceUnit.Day -> 365L + PaykitRecurrenceUnit.Week -> 52L + PaykitRecurrenceUnit.Month -> 12L + PaykitRecurrenceUnit.Year -> 1L + } + val denominator = subscription.recurrence.every.toLong() * 12 + val monthlyCost = BigDecimal(subscription.amount.atomic.toString()) + .multiply(BigDecimal.valueOf(annualPeriods)) + .divide(BigDecimal.valueOf(denominator), MathContext.DECIMAL128) + .setScale(0, RoundingMode.HALF_UP) + total.add(monthlyCost) } - val denominator = subscription.recurrence.every.toLong() * 12 - val monthlyCost = BigDecimal(subscription.amountSats.toString()) - .multiply(BigDecimal.valueOf(annualPeriods)) - .divide(BigDecimal.valueOf(denominator), MathContext.DECIMAL128) - .setScale(0, RoundingMode.HALF_UP) - total.add(monthlyCost) + PaykitAmount(asset, total.coerceAtMost(BigDecimal(ULong.MAX_VALUE.toString())).toPlainString().toULong()) } - return total.coerceAtMost(BigDecimal.valueOf(Long.MAX_VALUE)) - .toLong() } diff --git a/app/src/main/java/to/bitkit/ui/screens/trezor/TrezorPreviewData.kt b/app/src/main/java/to/bitkit/ui/screens/trezor/TrezorPreviewData.kt index c1d8a5c16b..966cadb388 100644 --- a/app/src/main/java/to/bitkit/ui/screens/trezor/TrezorPreviewData.kt +++ b/app/src/main/java/to/bitkit/ui/screens/trezor/TrezorPreviewData.kt @@ -121,6 +121,9 @@ internal object TrezorPreviewData { val samplePublicKeyResponse = TrezorPublicKeyResponse( xpub = SAMPLE_XPUB, + xpubSegwit = null, + descriptor = null, + displayablePublicKey = SAMPLE_XPUB, path = "m/84'/0'/0'", publicKey = SAMPLE_PUBKEY, chainCode = SAMPLE_CHAIN_CODE, diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/HomeScreen.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/HomeScreen.kt index cfdd51f96e..16874911a4 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/HomeScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/HomeScreen.kt @@ -164,6 +164,7 @@ import to.bitkit.ui.navigateToTransferIntro import to.bitkit.ui.scaffold.AppAlertDialog import to.bitkit.ui.screens.wallets.activity.components.ActivityListSimple import to.bitkit.ui.screens.wallets.activity.utils.previewActivityItems +import to.bitkit.ui.screens.wallets.usdt.UsdtWalletCard import to.bitkit.ui.screens.widgets.blocks.BlockCard import to.bitkit.ui.screens.widgets.blocks.BlockCardSmall import to.bitkit.ui.screens.widgets.blocks.WeatherModel @@ -394,6 +395,7 @@ fun HomeScreen( onNavigateToSavings = { walletNavController.navigate(Routes.Savings) }, onNavigateToSpending = { walletNavController.navigate(Routes.Spending) }, onClickHardwareWallet = { walletNavController.navigateTo(Routes.HardwareWallet(it)) }, + onClickUsdt = { walletNavController.navigateTo(Routes.UsdtWallet) }, onCalculatorInputActiveChanged = onCalculatorInputActiveChanged, ) } @@ -435,6 +437,7 @@ private fun Content( onNavigateToSavings: () -> Unit = {}, onNavigateToSpending: () -> Unit = {}, onClickHardwareWallet: (String) -> Unit = {}, + onClickUsdt: () -> Unit = {}, onCalculatorInputActiveChanged: (Boolean) -> Unit = {}, hazeState: HazeState = rememberHazeState(), balances: BalanceState = LocalBalances.current, @@ -571,6 +574,7 @@ private fun Content( onNavigateToSavings = onNavigateToSavings, onNavigateToSpending = onNavigateToSpending, onClickHardwareWallet = onClickHardwareWallet, + onClickUsdt = onClickUsdt, ) 1 -> WidgetsPage( @@ -613,6 +617,7 @@ private fun WalletPage( onNavigateToSavings: () -> Unit, onNavigateToSpending: () -> Unit, onClickHardwareWallet: (String) -> Unit, + onClickUsdt: () -> Unit, ) { val heightStatusBar = WindowInsets.statusBars.asPaddingValues().calculateTopPadding() val pullToRefreshState = rememberPullToRefreshState() @@ -659,6 +664,7 @@ private fun WalletPage( onNavigateToSavings = onNavigateToSavings, onNavigateToSpending = onNavigateToSpending, onClickHardwareWallet = onClickHardwareWallet, + onClickUsdt = onClickUsdt, ) VerticalSpacer(32.dp) @@ -724,6 +730,7 @@ private fun BalancesSection( onNavigateToSavings: () -> Unit, onNavigateToSpending: () -> Unit, onClickHardwareWallet: (String) -> Unit, + onClickUsdt: () -> Unit, ) { Column(modifier = Modifier.fillMaxWidth()) { Row( @@ -754,6 +761,7 @@ private fun BalancesSection( } HwDevices(wallets = hardwareWallets, onClick = onClickHardwareWallet) + if (!LocalInspectionMode.current && Env.isUsdtEnabled) UsdtWalletCard(onClick = onClickUsdt) } } diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/HomeViewModel.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/HomeViewModel.kt index 972591e4e0..8f68e33871 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/HomeViewModel.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/HomeViewModel.kt @@ -19,6 +19,7 @@ import kotlinx.coroutines.flow.update import kotlinx.coroutines.launch import to.bitkit.R import to.bitkit.data.SettingsStore +import to.bitkit.env.Env import to.bitkit.models.ActivityBannerType import to.bitkit.models.BannerItem import to.bitkit.models.Suggestion @@ -32,6 +33,7 @@ import to.bitkit.repositories.HwWalletRepo import to.bitkit.repositories.PubkyRepo import to.bitkit.repositories.SuggestionsRepo import to.bitkit.repositories.TransferRepo +import to.bitkit.repositories.UsdtRepo import to.bitkit.repositories.WalletRepo import to.bitkit.repositories.WidgetsRepo import to.bitkit.ui.screens.widgets.blocks.toWeatherModel @@ -51,6 +53,7 @@ class HomeViewModel @Inject constructor( private val activityRepo: ActivityRepo, private val hwWalletRepo: HwWalletRepo, private val suggestionsRepo: SuggestionsRepo, + private val usdtRepo: UsdtRepo, ) : ViewModel() { private val _uiState = MutableStateFlow(HomeUiState()) @@ -122,9 +125,16 @@ class HomeViewModel @Inject constructor( } } + observeEmptyState() + viewModelScope.launch { createBannersFlow() } + } + + private fun observeEmptyState() { @OptIn(ExperimentalCoroutinesApi::class) val hasActivityFlow = activityRepo.activitiesChanged.mapLatest { activityRepo.getActivities(walletId = null, limit = 1u).getOrNull()?.isNotEmpty() == true + }.combine(usdtRepo.state) { hasActivity, usdt -> + hasActivity || (Env.isUsdtEnabled && ((usdt.balance ?: 0uL) > 0uL || usdt.transfers.isNotEmpty())) } viewModelScope.launch { @@ -151,7 +161,6 @@ class HomeViewModel @Inject constructor( } }.collect() } - viewModelScope.launch { createBannersFlow() } } private fun setupArticleRotation() { diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/activity/components/ActivityListGrouped.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/activity/components/ActivityListGrouped.kt index 43ec8a2e7d..24945106a8 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/activity/components/ActivityListGrouped.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/activity/components/ActivityListGrouped.kt @@ -365,3 +365,17 @@ private fun PreviewEmptyWithFooter() { ) } } + +fun activityGroupTitleResource(timestamp: ULong): Int { + val today = Instant.now().atZone(ZoneId.systemDefault()).truncatedTo(ChronoUnit.DAYS) + val week = today.with(TemporalAdjusters.previousOrSame(WeekFields.of(Locale.getDefault()).firstDayOfWeek)) + val date = Instant.ofEpochSecond(timestamp.toLong()) + return when { + date >= today.toInstant() -> R.string.wallet__activity_group_today + date >= today.minusDays(1).toInstant() -> R.string.wallet__activity_group_yesterday + date >= week.toInstant() -> R.string.wallet__activity_group_week + date >= today.withDayOfMonth(1).toInstant() -> R.string.wallet__activity_group_month + date >= today.withDayOfYear(1).toInstant() -> R.string.wallet__activity_group_year + else -> R.string.wallet__activity_group_earlier + } +} diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/activity/components/ActivityRow.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/activity/components/ActivityRow.kt index b2cfa5f6c9..b9d1e4f628 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/activity/components/ActivityRow.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/activity/components/ActivityRow.kt @@ -5,6 +5,7 @@ import androidx.compose.foundation.background import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.RowScope import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.padding import androidx.compose.runtime.Composable @@ -104,15 +105,7 @@ fun ActivityRow( } } - Row( - verticalAlignment = Alignment.CenterVertically, - modifier = Modifier - .fillMaxWidth() - .clickableAlpha { onClick(item) } - .background(color = Colors.Gray6, shape = Shapes.medium) - .padding(16.dp) - .testTag(testTag) - ) { + ActivityRowSurface(onClick = { onClick(item) }, modifier = Modifier.testTag(testTag)) { ActivityIcon( activity = item, size = 40.dp, @@ -294,7 +287,7 @@ private fun AmountView( } @Composable -private fun AmountViewContent( +fun AmountViewContent( title: String, titlePrefix: String, subtitle: String, @@ -378,3 +371,17 @@ private fun Preview(@PreviewParameter(ActivityItemsPreviewProvider::class) item: ) } } + +@Composable +fun ActivityRowSurface( + onClick: () -> Unit, + modifier: Modifier = Modifier, + content: @Composable RowScope.() -> Unit, +) { + Row( + verticalAlignment = Alignment.CenterVertically, + content = content, + modifier = modifier.fillMaxWidth().clickableAlpha(onClick = onClick) + .background(Colors.Gray6, Shapes.medium).padding(16.dp) + ) +} diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveQrScreen.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveQrScreen.kt index 71221db7f3..8a3c4b0b2c 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveQrScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveQrScreen.kt @@ -404,7 +404,7 @@ fun ReceiveQrScreen( } else { { onClickEditInvoice(tab) } }, - tab = tab, + accentColor = tab.accentColor, modifier = Modifier.fillMaxWidth() ) } @@ -510,13 +510,14 @@ internal fun shouldAutoSwitchToAuto( @OptIn(ExperimentalMaterial3Api::class) @Composable -private fun ReceiveQrView( +fun ReceiveQrView( uri: String, copyText: String, - qrLogoPainter: Painter, - onClickEditInvoice: () -> Unit, - tab: ReceiveTab, + qrLogoPainter: Painter?, + onClickEditInvoice: (() -> Unit)?, + accentColor: Color, modifier: Modifier = Modifier, + shareContent: String = copyText, ) { val context = LocalContext.current val qrButtonTooltipState = rememberTooltipState() @@ -542,23 +543,25 @@ private fun ReceiveQrView( horizontalArrangement = Arrangement.spacedBy(8.dp), verticalAlignment = Alignment.Top, ) { - PrimaryButton( - text = stringResource(R.string.common__edit), - size = ButtonSize.Small, - onClick = onClickEditInvoice, - fullWidth = false, - icon = { - Icon( - painter = painterResource(R.drawable.ic_pencil_simple), - contentDescription = null, - tint = tab.accentColor, - modifier = Modifier.size(18.dp) - ) - }, - modifier = Modifier - .weight(1f) - .testTag("SpecifyInvoiceButton") - ) + if (onClickEditInvoice != null) { + PrimaryButton( + text = stringResource(R.string.common__edit), + size = ButtonSize.Small, + onClick = onClickEditInvoice, + fullWidth = false, + icon = { + Icon( + painter = painterResource(R.drawable.ic_pencil_simple), + contentDescription = null, + tint = accentColor, + modifier = Modifier.size(18.dp) + ) + }, + modifier = Modifier + .weight(1f) + .testTag("SpecifyInvoiceButton") + ) + } Box(modifier = Modifier.weight(1f)) { Tooltip( text = stringResource(R.string.wallet__receive_copied), @@ -576,7 +579,7 @@ private fun ReceiveQrView( Icon( painter = painterResource(R.drawable.ic_copy), contentDescription = null, - tint = tab.accentColor, + tint = accentColor, modifier = Modifier.size(18.dp) ) }, @@ -590,15 +593,15 @@ private fun ReceiveQrView( size = ButtonSize.Small, onClick = { qrBitmap?.let { bitmap -> - shareQrCode(context, bitmap, copyText) - } ?: shareText(context, copyText) + shareQrCode(context, bitmap, shareContent) + } ?: shareText(context, shareContent) }, fullWidth = false, icon = { Icon( painter = painterResource(R.drawable.ic_share), contentDescription = null, - tint = tab.accentColor, + tint = accentColor, modifier = Modifier.size(18.dp) ) }, @@ -791,11 +794,11 @@ enum class CopyAddressType { ONCHAIN, LIGHTNING } @OptIn(ExperimentalMaterial3Api::class) @Composable -private fun CopyAddressCard( +fun CopyAddressCard( title: String, address: String, type: CopyAddressType, - onClickEditInvoice: () -> Unit, + onClickEditInvoice: (() -> Unit)?, body: String? = null, testTag: String? = null, accentColor: Color? = null, @@ -825,45 +828,49 @@ private fun CopyAddressCard( Row( horizontalArrangement = Arrangement.spacedBy(8.dp) ) { - PrimaryButton( - text = stringResource(R.string.common__edit), - size = ButtonSize.Small, - onClick = onClickEditInvoice, - fullWidth = false, - icon = { - Icon( - painter = painterResource(R.drawable.ic_pencil_simple), - contentDescription = null, - tint = buttonAccentColor, - modifier = Modifier.size(18.dp) - ) - }, - modifier = Modifier - .weight(1f) - .testTag("SpecifyInvoiceButton") - ) - Tooltip( - text = stringResource(R.string.wallet__receive_copied), - tooltipState = tooltipState, - ) { - Box(modifier = Modifier.weight(1f)) { - PrimaryButton( - text = stringResource(R.string.common__copy), - size = ButtonSize.Small, - onClick = { - context.setClipboardText(address) - coroutineScope.launch { tooltipState.show() } - }, - fullWidth = false, - icon = { - Icon( - painter = painterResource(R.drawable.ic_copy), - contentDescription = null, - tint = buttonAccentColor, - modifier = Modifier.size(18.dp) - ) - }, - ) + if (onClickEditInvoice != null) { + PrimaryButton( + text = stringResource(R.string.common__edit), + size = ButtonSize.Small, + onClick = onClickEditInvoice, + fullWidth = false, + icon = { + Icon( + painter = painterResource(R.drawable.ic_pencil_simple), + contentDescription = null, + tint = buttonAccentColor, + modifier = Modifier.size(18.dp) + ) + }, + modifier = Modifier + .weight(1f) + .testTag("SpecifyInvoiceButton") + ) + } + Box(modifier = Modifier.weight(1f)) { + Tooltip( + text = stringResource(R.string.wallet__receive_copied), + tooltipState = tooltipState + ) { + Box { + PrimaryButton( + text = stringResource(R.string.common__copy), + size = ButtonSize.Small, + onClick = { + context.setClipboardText(address) + coroutineScope.launch { tooltipState.show() } + }, + fullWidth = true, + icon = { + Icon( + painter = painterResource(R.drawable.ic_copy), + contentDescription = null, + tint = buttonAccentColor, + modifier = Modifier.size(18.dp) + ) + }, + ) + } } } PrimaryButton( diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveSheet.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveSheet.kt index e71d3e1bb1..ad3c47e0c1 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveSheet.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveSheet.kt @@ -28,6 +28,8 @@ import androidx.navigation.compose.rememberNavController import androidx.navigation.toRoute import kotlinx.serialization.Serializable import to.bitkit.R +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset import to.bitkit.models.PubkyPublicKeyFormat import to.bitkit.repositories.LightningState import to.bitkit.repositories.PaykitPaymentRequest @@ -93,7 +95,7 @@ fun ReceiveSheet( var paymentRequestDraft by remember { mutableStateOf( PaykitPaymentRequestDraft( - amountSats = 0uL, + amount = PaykitAmount(PaykitAsset.BTC, 0uL), note = "", expiresAt = Clock.System.now() + 7.days, ) @@ -183,7 +185,7 @@ fun ReceiveSheet( showPaymentRequestContacts = paymentRequestTargets.isNotEmpty(), onClickPaymentRequestContacts = { paymentRequestDraft = paymentRequestDraft.copy( - amountSats = 0uL, + amount = PaykitAmount(PaykitAsset.BTC, 0uL), note = "", expiresAt = Clock.System.now() + 7.days, ) @@ -390,7 +392,7 @@ fun ReceiveSheet( showPaymentRequestButton = paymentRequestTargets.isNotEmpty(), onClickPaymentRequest = { amountSats, note -> paymentRequestDraft = PaykitPaymentRequestDraft( - amountSats = amountSats, + amount = PaykitAmount(PaykitAsset.BTC, amountSats), note = note, expiresAt = Clock.System.now() + 7.days, ) diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendAddressScreen.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendAddressScreen.kt index a1c472b3ec..2a84389d20 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendAddressScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendAddressScreen.kt @@ -7,7 +7,6 @@ import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.height import androidx.compose.foundation.layout.navigationBarsPadding import androidx.compose.foundation.layout.padding -import androidx.compose.foundation.text.KeyboardOptions import androidx.compose.runtime.Composable import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.remember @@ -16,22 +15,18 @@ import androidx.compose.ui.focus.FocusRequester import androidx.compose.ui.focus.focusRequester import androidx.compose.ui.platform.testTag import androidx.compose.ui.res.stringResource -import androidx.compose.ui.text.input.ImeAction -import androidx.compose.ui.text.input.KeyboardCapitalization import androidx.compose.ui.tooling.preview.Preview import androidx.compose.ui.unit.dp import kotlinx.coroutines.delay import to.bitkit.R import to.bitkit.ui.components.BottomSheetPreview import to.bitkit.ui.components.Caption13Up +import to.bitkit.ui.components.PaymentAddressInput import to.bitkit.ui.components.PrimaryButton -import to.bitkit.ui.components.TextInput import to.bitkit.ui.components.VerticalSpacer import to.bitkit.ui.scaffold.SheetTopBar import to.bitkit.ui.shared.modifiers.sheetHeight import to.bitkit.ui.shared.util.gradientBackground -import to.bitkit.ui.theme.AppTextFieldDefaults -import to.bitkit.ui.theme.AppTextStyles import to.bitkit.ui.theme.AppThemeSurface import to.bitkit.ui.theme.Colors import to.bitkit.ui.theme.TRANSITION_SCREEN_MS @@ -69,27 +64,11 @@ fun SendAddressScreen( color = Colors.White64, ) VerticalSpacer(8.dp) - TextInput( - placeholder = stringResource(R.string.wallet__send_address_placeholder), + PaymentAddressInput( value = uiState.addressInput, onValueChange = { onEvent(SendEvent.AddressChange(it)) }, - minLines = 12, - keyboardOptions = KeyboardOptions( - capitalization = KeyboardCapitalization.None, - imeAction = ImeAction.Done, - autoCorrectEnabled = false - ), - textStyle = AppTextStyles.Title, - colors = AppTextFieldDefaults.semiTransparent.copy( - focusedContainerColor = Colors.White06, - unfocusedContainerColor = Colors.White06, - errorContainerColor = Colors.White06, - ), - modifier = Modifier - .fillMaxWidth() - .focusRequester(focusRequester) - .weight(1f) - .testTag("RecipientInput") + placeholder = stringResource(R.string.wallet__send_address_placeholder), + modifier = Modifier.fillMaxWidth().focusRequester(focusRequester).weight(1f).testTag("RecipientInput") ) VerticalSpacer(16.dp) PrimaryButton( diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendAmountScreen.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendAmountScreen.kt index b24890b525..9d3667258a 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendAmountScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendAmountScreen.kt @@ -16,6 +16,7 @@ import androidx.compose.runtime.remember import androidx.compose.runtime.rememberUpdatedState import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color import androidx.compose.ui.platform.LocalContext import androidx.compose.ui.platform.testTag import androidx.compose.ui.res.stringResource @@ -26,6 +27,7 @@ import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel import androidx.lifecycle.compose.collectAsStateWithLifecycle import com.synonym.bitkitcore.LnurlPayData import com.synonym.bitkitcore.LnurlWithdrawData +import com.synonym.bitkitcore.usdtFormatAmount import to.bitkit.R import to.bitkit.ext.maxSendableSat import to.bitkit.ext.maxWithdrawableSat @@ -38,6 +40,7 @@ import to.bitkit.repositories.CurrencyState import to.bitkit.ui.LocalBalances import to.bitkit.ui.LocalCurrencies import to.bitkit.ui.appViewModel +import to.bitkit.ui.components.BodySSB import to.bitkit.ui.components.BottomSheetPreview import to.bitkit.ui.components.FillHeight import to.bitkit.ui.components.FillWidth @@ -45,7 +48,9 @@ import to.bitkit.ui.components.HorizontalSpacer import to.bitkit.ui.components.MoneySSB import to.bitkit.ui.components.NumberPad import to.bitkit.ui.components.NumberPadActionButton +import to.bitkit.ui.components.NumberPadAmountText import to.bitkit.ui.components.NumberPadTextField +import to.bitkit.ui.components.NumberPadType import to.bitkit.ui.components.PrimaryButton import to.bitkit.ui.components.SyncNodeView import to.bitkit.ui.components.Text13Up @@ -56,6 +61,7 @@ import to.bitkit.ui.shared.modifiers.sheetHeight import to.bitkit.ui.shared.util.gradientBackground import to.bitkit.ui.theme.AppThemeSurface import to.bitkit.ui.theme.Colors +import to.bitkit.ui.utils.NumberPadInputHandler import to.bitkit.viewmodels.AmountInputEffect import to.bitkit.viewmodels.AmountInputUiState import to.bitkit.viewmodels.AmountInputViewModel @@ -98,14 +104,19 @@ fun SendAmountScreen( } val currentMaxExceededMessage by rememberUpdatedState(maxExceededMessage) - LaunchedEffect(Unit) { - if (uiState.amount > 0u) { + val pendingRequests = app?.pendingPaymentRequests?.collectAsStateWithLifecycle()?.value + LaunchedEffect(pendingRequests, uiState.paykitUsesUsdt) { + app?.refreshPaykitRequestAmount() + } + + LaunchedEffect(uiState.paykitUsesUsdt, uiState.payMethod, uiState.amount.takeIf { uiState.isPaymentRequest }) { + if (!uiState.paykitUsesUsdt && uiState.amount > 0u) { amountInputViewModel.setSats(uiState.amount.toLong(), currencies) } } LaunchedEffect(amountInputUiState.sats) { - currentOnEvent(SendEvent.AmountChange(amountInputUiState.sats.toULong())) + if (!uiState.paykitUsesUsdt) currentOnEvent(SendEvent.AmountChange(amountInputUiState.sats.toULong())) } LaunchedEffect(Unit) { @@ -179,7 +190,7 @@ fun SendAmountContent( val titleRes = when (uiState.lnurl) { is LnurlParams.LnurlWithdraw -> R.string.wallet__lnurl_w_title is LnurlParams.LnurlPay -> R.string.wallet__lnurl_p_title - else -> R.string.wallet__send_amount + else -> if (uiState.paykitUsesUsdt) R.string.usdt__amount else R.string.wallet__send_amount } SendContactTopBar( @@ -188,8 +199,8 @@ fun SendAmountContent( onBack = onBack, ) - when (nodeLifecycleState) { - is NodeLifecycleState.Running -> { + when { + nodeLifecycleState is NodeLifecycleState.Running || uiState.paykitUsesUsdt -> { SendAmountNodeRunning( amountInputViewModel = amountInputViewModel, uiState = uiState, @@ -224,6 +235,9 @@ private fun SendAmountNodeRunning( onClickMax: (Long) -> Unit, onContinue: () -> Unit, ) { + val app = appViewModel + val usdtWallet = app?.usdtWallet?.collectAsStateWithLifecycle()?.value + val hideBalance = to.bitkit.ui.settingsViewModel?.hideBalance?.collectAsStateWithLifecycle()?.value == true BoxWithConstraints { val maxHeight = this.maxHeight val isLnurlWithdraw = uiState.lnurl is LnurlParams.LnurlWithdraw @@ -253,14 +267,28 @@ private fun SendAmountNodeRunning( ) { VerticalSpacer(16.dp) - NumberPadTextField( - viewModel = amountInputViewModel, - modifier = Modifier - .fillMaxWidth() - .testTag("SendNumberField") - ) + if (uiState.paykitUsesUsdt) { + NumberPadAmountText( + value = uiState.paykitAmount.ifEmpty { "0" }, + symbol = "₮", + modifier = Modifier.testTag("SendNumberField") + ) + } else { + NumberPadTextField( + viewModel = amountInputViewModel, + modifier = Modifier + .fillMaxWidth() + .testTag("SendNumberField") + ) + } FillHeight(min = 12.dp) + if (uiState.paykitRateUnavailable) { + to.bitkit.ui.components.BodyS( + stringResource(R.string.wallet__payment_request_rate_unavailable), + color = Colors.White64 + ) + } val textAvailable = when { uiState.lnurl is LnurlParams.LnurlWithdraw -> R.string.wallet__lnurl_w_max @@ -276,7 +304,9 @@ private fun SendAmountNodeRunning( ) { Column( modifier = Modifier - .clickableAlpha { onClickMax(availableAmount) } + .clickableAlpha( + enabled = !uiState.isPaymentRequest && !uiState.paykitUsesUsdt + ) { onClickMax(availableAmount) } .testTag("AvailableAmount") ) { Text13Up( @@ -285,16 +315,25 @@ private fun SendAmountNodeRunning( modifier = Modifier.testTag("available_balance") ) VerticalSpacer(4.dp) - MoneySSB(sats = availableAmount, showSymbol = true) + if (uiState.paykitUsesUsdt) { + val balance = if (hideBalance) { + to.bitkit.ui.shared.UiConstants.HIDE_BALANCE_SHORT + } else { + usdtWallet?.balance?.let(::usdtFormatAmount) ?: "—" + } + BodySSB("$balance USDT") + } else { + MoneySSB(sats = availableAmount, showSymbol = true) + } } FillWidth() val isLnurl = uiState.lnurl != null - if (!isLnurl) { + if (!isLnurl || uiState.usdtRecipient != null) { PaymentMethodButton(uiState = uiState, onClick = onClickPayMethod) } - if (uiState.lnurl is LnurlParams.LnurlPay) { + if (!uiState.isPaymentRequest && !uiState.paykitUsesUsdt && uiState.lnurl is LnurlParams.LnurlPay) { val max = minOf( uiState.lnurl.data.maxSendableSat().toLong(), availableAmount, @@ -308,23 +347,39 @@ private fun SendAmountNodeRunning( ) } HorizontalSpacer(8.dp) - UnitButton( - onClick = { amountInputViewModel.switchUnit(currencies) }, - modifier = Modifier - .height(28.dp) - .testTag("SendNumberPadUnit") - ) + if (!uiState.paykitUsesUsdt) { + UnitButton( + onClick = { amountInputViewModel.switchUnit(currencies) }, + modifier = Modifier + .height(28.dp) + .testTag("SendNumberPadUnit") + ) + } } HorizontalDivider(modifier = Modifier.padding(top = 12.dp)) - NumberPad( - viewModel = amountInputViewModel, - currencies = currencies, - availableHeight = maxHeight, - modifier = Modifier - .testTag("SendAmountNumberPad") - ) + if (uiState.paykitUsesUsdt) { + NumberPad( + type = NumberPadType.DECIMAL, + enabled = !uiState.isPaymentRequest, + onPress = { + app?.onUsdtAmountChange( + NumberPadInputHandler.handleInput(it, uiState.paykitAmount, maxLength = 21, maxDecimals = 6) + ) + }, + onDeleteLongPress = { app?.onUsdtAmountChange("") } + ) + } else { + NumberPad( + enabled = !uiState.isPaymentRequest, + viewModel = amountInputViewModel, + currencies = currencies, + availableHeight = maxHeight, + modifier = Modifier + .testTag("SendAmountNumberPad") + ) + } PrimaryButton( text = stringResource(R.string.common__continue), @@ -347,21 +402,19 @@ private fun PaymentMethodButton( val isHardware = uiState.hardwareWalletId != null val testId = when { uiState.canSwitchFundingSource -> "switch" + uiState.paykitUsesUsdt -> "usdt" isHardware -> "trezor" uiState.payMethod == SendMethod.ONCHAIN -> "savings" else -> "spending" } NumberPadActionButton( text = when { + uiState.paykitUsesUsdt -> "USDT" isHardware -> uiState.hardwareWalletName ?: stringResource(R.string.hardware__device_model_trezor) uiState.payMethod == SendMethod.ONCHAIN -> stringResource(R.string.wallet__savings__title) else -> stringResource(R.string.wallet__spending__title) }, - color = when { - isHardware -> Colors.Blue - uiState.payMethod == SendMethod.ONCHAIN -> Colors.Brand - else -> Colors.Purple - }, + color = paymentMethodColor(uiState), icon = if (uiState.canSwitchFundingSource) R.drawable.ic_transfer else null, onClick = onClick, enabled = uiState.canSwitchFundingSource, @@ -373,6 +426,13 @@ private fun PaymentMethodButton( ) } +private fun paymentMethodColor(uiState: SendUiState): Color = when { + uiState.paykitUsesUsdt -> Colors.Green + uiState.hardwareWalletId != null -> Colors.Blue + uiState.payMethod == SendMethod.ONCHAIN -> Colors.Brand + else -> Colors.Purple +} + @Preview(showSystemUi = true) @Composable private fun PreviewLightningNoAmount() { diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendConfirmScreen.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendConfirmScreen.kt index 2ab742051e..1e15f8b8a4 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendConfirmScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendConfirmScreen.kt @@ -3,7 +3,6 @@ package to.bitkit.ui.screens.wallets.send import androidx.annotation.DrawableRes import androidx.compose.animation.animateContentSize import androidx.compose.animation.core.tween -import androidx.compose.foundation.Image import androidx.compose.foundation.background import androidx.compose.foundation.horizontalScroll import androidx.compose.foundation.layout.Arrangement @@ -41,8 +40,6 @@ import androidx.compose.runtime.setValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.graphics.Color -import androidx.compose.ui.graphics.graphicsLayer -import androidx.compose.ui.layout.ContentScale import androidx.compose.ui.platform.testTag import androidx.compose.ui.res.painterResource import androidx.compose.ui.res.stringResource @@ -66,6 +63,7 @@ import to.bitkit.R import to.bitkit.ext.commentAllowed import to.bitkit.ext.formatInvoiceExpiryRelative import to.bitkit.models.FeeRate +import to.bitkit.models.PaykitAsset import to.bitkit.models.PubkyProfile import to.bitkit.models.TransactionSpeed import to.bitkit.repositories.PaykitPaymentRequest @@ -79,6 +77,8 @@ import to.bitkit.ui.components.Caption13Up import to.bitkit.ui.components.FillHeight import to.bitkit.ui.components.GradientCircularProgressIndicator import to.bitkit.ui.components.NumberPadActionButton +import to.bitkit.ui.components.PaykitAmountDisplay +import to.bitkit.ui.components.PaymentReviewIllustration import to.bitkit.ui.components.PrimaryButton import to.bitkit.ui.components.PubkyContactAvatar import to.bitkit.ui.components.SendCell @@ -112,6 +112,7 @@ private val EXPIRY_REFRESH_INTERVAL = 60.seconds private const val SWIPE_ROTATION_DEGREES = 14f private const val IMAGE_FILL_PERCENTAGE = 0.8f const val SEND_CONFIRM_RESET_RESULT_KEY = "SEND_CONFIRM_RESET_RESULT_KEY" +const val HARDWARE_SIGN_CANCELLED_RESULT_KEY = "HARDWARE_SIGN_CANCELLED_RESULT_KEY" @Suppress("MagicNumber") @Composable @@ -374,15 +375,19 @@ private fun ContentRunning( .padding(horizontal = 16.dp) .fillMaxSize() ) { - BalanceHeaderView( - sats = (preparingRequest?.amountSats ?: uiState.amount).toLong(), - useSwipeToHide = false, - onClick = { onEvent(SendEvent.BackToAmount) }.takeUnless { isPreparing }, - testTag = "ReviewAmount", - modifier = Modifier - .fillMaxWidth() - .testTag("ReviewAmount") - ) + if (preparingRequest != null && preparingRequest.amount.asset != PaykitAsset.BTC) { + PaykitAmountDisplay(preparingRequest.amount) + } else { + BalanceHeaderView( + sats = (preparingRequest?.amount?.atomic ?: uiState.amount).toLong(), + useSwipeToHide = false, + onClick = { onEvent(SendEvent.BackToAmount) }.takeUnless { isPreparing }, + testTag = "ReviewAmount", + modifier = Modifier + .fillMaxWidth() + .testTag("ReviewAmount") + ) + } BoxWithConstraints( modifier = Modifier @@ -435,16 +440,9 @@ private fun ContentRunning( ) VerticalSpacer(16.dp) } - Image( - painter = painterResource(R.drawable.coin_stack_4), - contentDescription = null, - contentScale = ContentScale.Fit, - modifier = Modifier - .fillMaxWidth(IMAGE_FILL_PERCENTAGE) - .weight(1f) - .align(Alignment.CenterHorizontally) - .padding(bottom = 16.dp) - .graphicsLayer { rotationZ = swipeProgress.floatValue * SWIPE_ROTATION_DEGREES } + PaymentReviewIllustration( + swipeProgress = { swipeProgress.floatValue }, + modifier = Modifier.weight(1f) ) } } diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendContactSelectScreen.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendContactSelectScreen.kt index 1dc7352738..7c127898e0 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendContactSelectScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendContactSelectScreen.kt @@ -22,6 +22,7 @@ import kotlinx.collections.immutable.ImmutableList import kotlinx.collections.immutable.persistentListOf import to.bitkit.R import to.bitkit.models.PubkyProfile +import to.bitkit.repositories.Endpoint import to.bitkit.repositories.PrivatePaykitPaymentContext import to.bitkit.ui.components.BodyM import to.bitkit.ui.components.GradientCircularProgressIndicator @@ -35,7 +36,7 @@ import to.bitkit.ui.theme.Colors fun SendContactSelectScreen( viewModel: SendContactSelectViewModel, onBack: () -> Unit, - onOpenPayment: (String, String, PrivatePaykitPaymentContext?) -> Unit, + onOpenPayment: (String, String, PrivatePaykitPaymentContext?, List) -> Unit, ) { val uiState by viewModel.uiState.collectAsStateWithLifecycle() @@ -43,7 +44,7 @@ fun SendContactSelectScreen( viewModel.effects.collect { when (it) { is SendContactSelectEffect.OpenPayment -> - onOpenPayment(it.paymentRequest, it.publicKey, it.privatePaymentContext) + onOpenPayment(it.paymentRequest, it.publicKey, it.privatePaymentContext, it.endpoints) } } } diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendContactSelectViewModel.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendContactSelectViewModel.kt index 12a0cb0dbc..bc31cc868d 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendContactSelectViewModel.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendContactSelectViewModel.kt @@ -19,6 +19,7 @@ import kotlinx.coroutines.launch import to.bitkit.R import to.bitkit.models.PubkyProfile import to.bitkit.models.Toast +import to.bitkit.repositories.Endpoint import to.bitkit.repositories.PrivatePaykitPaymentContext import to.bitkit.repositories.PrivatePaykitRepo import to.bitkit.repositories.PubkyRepo @@ -75,6 +76,7 @@ class SendContactSelectViewModel @Inject constructor( result.paymentRequest, publicKey, result.privatePaymentContext, + result.endpoints, ) ) PublicPaykitPaymentResult.NoEndpoint -> @@ -120,5 +122,6 @@ sealed interface SendContactSelectEffect { val paymentRequest: String, val publicKey: String, val privatePaymentContext: PrivatePaykitPaymentContext?, + val endpoints: List = emptyList(), ) : SendContactSelectEffect } diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendPendingScreen.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendPendingScreen.kt index afe13bbb41..96d6d8326b 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendPendingScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendPendingScreen.kt @@ -380,7 +380,7 @@ internal fun SendPendingContent( } @Composable -private fun HourglassAnimation(modifier: Modifier = Modifier) { +fun HourglassAnimation(modifier: Modifier = Modifier) { val infiniteTransition = rememberInfiniteTransition(label = "hourglass") val rotation by infiniteTransition.animateFloat( initialValue = -16f, diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/PaykitUsdtReview.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/PaykitUsdtReview.kt new file mode 100644 index 0000000000..4fa167a692 --- /dev/null +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/PaykitUsdtReview.kt @@ -0,0 +1,137 @@ +package to.bitkit.ui.screens.wallets.usdt + +import androidx.activity.compose.BackHandler +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.padding +import androidx.compose.runtime.Composable +import androidx.compose.runtime.DisposableEffect +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.unit.dp +import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel +import androidx.lifecycle.Lifecycle +import androidx.lifecycle.compose.LocalLifecycleOwner +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import androidx.lifecycle.repeatOnLifecycle +import com.synonym.bitkitcore.UsdtDestination +import com.synonym.bitkitcore.UsdtTransferStatus +import kotlinx.coroutines.delay +import to.bitkit.R +import to.bitkit.ui.scaffold.AppAlertDialog +import to.bitkit.ui.shared.modifiers.sheetHeight +import to.bitkit.ui.shared.util.gradientBackground +import to.bitkit.viewmodels.AppViewModel +import to.bitkit.viewmodels.SendUiState +import kotlin.time.Duration.Companion.seconds + +@Composable +fun PaykitUsdtReview( + uiState: SendUiState, + app: AppViewModel, + onBack: () -> Unit, + onDone: () -> Unit, + viewModel: UsdtViewModel = hiltViewModel() +) { + val wallet by viewModel.wallet.collectAsStateWithLifecycle() + val state by viewModel.state.collectAsStateWithLifecycle() + val settings by viewModel.settings.collectAsStateWithLifecycle() + val lifecycle = LocalLifecycleOwner.current.lifecycle + DisposableEffect(state.busy, state.authenticationRequired) { + app.updatePaykitUsdtBusy(state.busy || state.authenticationRequired) + onDispose { app.updatePaykitUsdtBusy(false) } + } + var details by remember { mutableStateOf(false) } + val back = { + if (!state.busy && !state.authenticationRequired) { + if (state.submitted) onDone() else onBack() + } + } + DisposableEffect(viewModel) { + viewModel.sendPayment = app::sendPaykitUsdt + viewModel.isSendPresented = true + onDispose { + viewModel.sendPayment = null + viewModel.isSendPresented = false + } + } + LaunchedEffect(Unit) { + viewModel.quote(requireNotNull(uiState.usdtRecipient), uiState.paykitAmount, UsdtDestination.ARBITRUM) + } + LaunchedEffect(state.submitted, lifecycle) { + if (state.submitted) { + lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) { + reconcileSubmittedPayment(viewModel, app) + } + } + } + BackHandler { if (state.authenticationRequired) viewModel.cancelAuthentication() else back() } + state.warning?.let { warning -> + AppAlertDialog( + title = stringResource(R.string.common__are_you_sure), + text = stringResource(warning.message), + confirmText = stringResource(R.string.wallet__send_yes), + dismissText = stringResource(R.string.common__cancel), + onConfirm = viewModel::acceptWarning, + onDismiss = viewModel::edit + ) + } + val transfer = wallet.transfers.firstOrNull { it.id == state.quote?.id } + if (details && transfer != null) { + UsdtActivityDetail(transfer, settings.hideBalance) { details = false } + } else { + Column( + Modifier.sheetHeight().gradientBackground().padding( + horizontal = if (state.submitted && transfer?.status == UsdtTransferStatus.CONFIRMED) 0.dp else 16.dp + ) + ) { + if (state.authenticationRequired) { + UsdtAuthentication( + settings.isBiometricEnabled, + viewModel::cancelAuthentication, + viewModel::authenticationVerified + ) + } else { + UsdtPaymentContent( + wallet, state, UsdtPage.AMOUNT, + uiState.usdtRecipient.orEmpty(), uiState.paykitAmount, UsdtDestination.ARBITRUM, + onRecipientChange = {}, + onAmountChange = {}, + onRecipientContinue = {}, + onPageChange = { back() }, + onBack = back, + onReview = { + viewModel.quote( + requireNotNull(uiState.usdtRecipient), + uiState.paykitAmount, + UsdtDestination.ARBITRUM + ) + }, + onConfirm = { + viewModel.confirm() + }, + onDone = onDone, + onDetails = { details = true }, + hideBalance = settings.hideBalance, + amountEditable = false + ) + } + } + } +} + +private suspend fun reconcileSubmittedPayment(viewModel: UsdtViewModel, app: AppViewModel) { + viewModel.waitForTransfer() + while (viewModel.wallet.value.transfers.any { + it.id == viewModel.state.value.quote?.id && it.status == UsdtTransferStatus.PENDING + } + ) { + delay(10.seconds) + viewModel.refresh() + } + app.reconcilePaykitUsdt() +} diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtActivityDetail.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtActivityDetail.kt new file mode 100644 index 0000000000..0aa487034d --- /dev/null +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtActivityDetail.kt @@ -0,0 +1,266 @@ +package to.bitkit.ui.screens.wallets.usdt + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.text.selection.SelectionContainer +import androidx.compose.foundation.verticalScroll +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.LocalUriHandler +import androidx.compose.ui.platform.testTag +import androidx.compose.ui.res.painterResource +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.unit.dp +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import com.synonym.bitkitcore.UsdtDestination +import com.synonym.bitkitcore.UsdtTransfer +import com.synonym.bitkitcore.UsdtTransferStatus +import com.synonym.bitkitcore.usdtFormatAmount +import to.bitkit.R +import to.bitkit.ext.UiDateStyle +import to.bitkit.ext.uiDateStyleFor +import to.bitkit.ui.components.BodyMSB +import to.bitkit.ui.components.BodyS +import to.bitkit.ui.components.BodySSB +import to.bitkit.ui.components.CaptionB +import to.bitkit.ui.components.HorizontalSpacer +import to.bitkit.ui.components.SecondaryButton +import to.bitkit.ui.components.SendCell +import to.bitkit.ui.components.UsdtAmountHeader +import to.bitkit.ui.components.VerticalSpacer +import to.bitkit.ui.scaffold.AppTopBar +import to.bitkit.ui.scaffold.DrawerNavIcon +import to.bitkit.ui.screens.wallets.activity.components.ActivityRowSurface +import to.bitkit.ui.screens.wallets.activity.components.AmountViewContent +import to.bitkit.ui.screens.wallets.activity.components.CircularIcon +import to.bitkit.ui.shared.UiConstants +import to.bitkit.ui.theme.Colors +import to.bitkit.ui.utils.uiDateText + +@Composable +internal fun UsdtActivityRow(transfer: UsdtTransfer, hideBalance: Boolean, onClick: () -> Unit) { + val contactName = paykitContactName(transfer.id) + ActivityRowSurface(onClick = onClick, modifier = Modifier.testTag("UsdtActivity-" + transfer.id)) { + UsdtActivityIcon(transfer) + HorizontalSpacer(16.dp) + Column(verticalArrangement = Arrangement.spacedBy(2.dp), modifier = Modifier.weight(1f)) { + BodyMSB(contactName ?: stringResource(transfer.titleResource), maxLines = 1) + CaptionB( + uiDateText(transfer.timestamp, uiDateStyleFor(transfer.timestamp)), + color = Colors.White64, + maxLines = 1 + ) + } + HorizontalSpacer(16.dp) + AmountViewContent( + title = usdtFormatAmount(transfer.activityAmount), + titlePrefix = if (transfer.isIncoming) "+" else "−", + subtitle = "USDT", + hideBalance = hideBalance + ) + } +} + +@Composable +private fun UsdtActivityIcon(transfer: UsdtTransfer) { + CircularIcon( + icon = painterResource(transfer.iconResource), + iconColor = transfer.statusColor, + backgroundColor = transfer.statusColor.copy(alpha = 0.16f), + size = 40.dp + ) +} + +@Composable +internal fun UsdtActivityDetail(transfer: UsdtTransfer, hideBalance: Boolean, onBack: () -> Unit) { + val contactName = paykitContactName(transfer.id) + Column(modifier = Modifier.fillMaxSize()) { + AppTopBar( + titleText = stringResource(transfer.titleResource), + onBackClick = onBack, + actions = { DrawerNavIcon() } + ) + Column( + verticalArrangement = Arrangement.spacedBy(16.dp), + modifier = Modifier.verticalScroll(rememberScrollState()).padding(horizontal = 16.dp) + ) { + Row(verticalAlignment = Alignment.Bottom) { + UsdtAmountHeader( + usdtFormatAmount(transfer.activityAmount), + transfer.destination.label, + hideBalance = hideBalance, + prefix = if (transfer.isIncoming) "+" else "−", + modifier = Modifier.weight(1f) + ) + UsdtActivityIcon(transfer) + } + VerticalSpacer(16.dp) + if (contactName != null) { + SendCell( + caption = stringResource( + if (transfer.isIncoming) R.string.wallet__send_from else R.string.wallet__send_to + ) + ) { + BodySSB(contactName) + } + } + SendCell(caption = stringResource(R.string.wallet__activity_status)) { + BodySSB( + stringResource(transfer.status.labelResource), + color = transfer.statusColor, + modifier = Modifier.testTag("UsdtActivityStatus") + ) + } + Row(horizontalArrangement = Arrangement.spacedBy(16.dp)) { + SendCell(caption = stringResource(R.string.wallet__activity_date), modifier = Modifier.weight(1f)) { + BodySSB(uiDateText(transfer.timestamp, UiDateStyle.DATE)) + } + SendCell(caption = stringResource(R.string.wallet__activity_time), modifier = Modifier.weight(1f)) { + BodySSB(uiDateText(transfer.timestamp, UiDateStyle.TIME)) + } + } + SendCell(caption = stringResource(R.string.usdt__destination)) { BodySSB(transfer.destination.label) } + if (!transfer.isIncoming) { + SendCell( + caption = stringResource(R.string.usdt__address) + ) { SelectionContainer { BodySSB(transfer.recipient) } } + Row(horizontalArrangement = Arrangement.spacedBy(16.dp)) { + if ( + transfer.status != UsdtTransferStatus.FAILED && transfer.status != UsdtTransferStatus.REPLACED + ) { + SendCell( + caption = stringResource( + if (transfer.destination != UsdtDestination.ARBITRUM && + transfer.status != UsdtTransferStatus.CONFIRMED + ) { + R.string.usdt__expected_amount + } else { + R.string.usdt__recipient_gets + } + ), + modifier = Modifier.weight(1f) + ) { + BodySSB( + ( + if (hideBalance) { + UiConstants.HIDE_BALANCE_SHORT + } else { + usdtFormatAmount(transfer.receivedAmount) + } + ) + " USDT" + ) + } + } + SendCell(caption = stringResource(R.string.wallet__activity_fee), modifier = Modifier.weight(1f)) { + BodySSB( + if (hideBalance) { + UiConstants.HIDE_BALANCE_SHORT + } else { + transfer.fee?.let { usdtFormatAmount(it) + " USDT" } + ?: "—" + } + ) + } + } + } + transfer.orchestra?.let { UsdtOrchestraDetails(it, hideBalance) } + UsdtTransactionDetails(transfer) + VerticalSpacer(120.dp) + } + } +} + +private val UsdtTransfer.titleResource: Int get() = when (status) { + UsdtTransferStatus.FAILED, UsdtTransferStatus.REPLACED, UsdtTransferStatus.PENDING, + UsdtTransferStatus.BRIDGE_REFUNDED, UsdtTransferStatus.BRIDGING, + UsdtTransferStatus.BRIDGE_NEEDS_ATTENTION, UsdtTransferStatus.BRIDGE_FAILED -> + status.labelResource + else -> if (isIncoming) R.string.usdt__received else R.string.usdt__sent +} + +private val UsdtTransfer.iconResource: Int get() = when (status) { + UsdtTransferStatus.FAILED, UsdtTransferStatus.REPLACED, UsdtTransferStatus.BRIDGE_FAILED -> R.drawable.ic_x + UsdtTransferStatus.PENDING, UsdtTransferStatus.BRIDGING, + UsdtTransferStatus.BRIDGE_NEEDS_ATTENTION -> R.drawable.ic_timer_alt + UsdtTransferStatus.BRIDGE_REFUNDED -> R.drawable.ic_received + UsdtTransferStatus.CONFIRMED -> if (isIncoming) R.drawable.ic_received else R.drawable.ic_sent +} + +private val UsdtTransfer.statusColor get() = when (status) { + UsdtTransferStatus.FAILED, UsdtTransferStatus.REPLACED -> Colors.Red + UsdtTransferStatus.BRIDGE_NEEDS_ATTENTION, UsdtTransferStatus.BRIDGE_FAILED -> Colors.Yellow + else -> Colors.Green +} + +private val UsdtTransferStatus.labelResource: Int get() = when (this) { + UsdtTransferStatus.PENDING -> R.string.usdt__pending + UsdtTransferStatus.CONFIRMED -> R.string.usdt__confirmed + UsdtTransferStatus.FAILED -> R.string.usdt__failed + UsdtTransferStatus.BRIDGING -> R.string.usdt__bridging + UsdtTransferStatus.BRIDGE_NEEDS_ATTENTION, UsdtTransferStatus.BRIDGE_FAILED -> R.string.usdt__bridge_attention + UsdtTransferStatus.BRIDGE_REFUNDED -> R.string.usdt__deposit_refunded + UsdtTransferStatus.REPLACED -> R.string.usdt__replaced +} + +internal val UsdtTransfer.activityAmount: ULong get() { + if (isIncoming) return amount + if (status == UsdtTransferStatus.FAILED || status == UsdtTransferStatus.REPLACED) return fee ?: 0u + val fee = fee ?: return amount + return if (ULong.MAX_VALUE - amount < fee) ULong.MAX_VALUE else amount + fee +} + +@Composable +private fun paykitContactName(transferId: String): String? { + val app = to.bitkit.ui.appViewModel ?: return null + val attempts by app.paykitUsdtPayments.attempts.collectAsStateWithLifecycle() + val receipts by app.paykitUsdtPayments.receipts.collectAsStateWithLifecycle() + val contacts by app.pubkyContacts.collectAsStateWithLifecycle() + val key = attempts.firstOrNull { it.quoteId == transferId }?.contact + ?: receipts.firstOrNull { it.transferId == transferId }?.requestId?.counterparty ?: return null + return contacts.firstOrNull { to.bitkit.models.PubkyPublicKeyFormat.matches(it.publicKey, key) }?.name + ?: to.bitkit.models.PubkyPublicKeyFormat.display(key) +} + +@Composable +private fun UsdtOrchestraDetails(bridge: com.synonym.bitkitcore.UsdtOrchestraTransfer, hideBalance: Boolean) { + SendCell(caption = stringResource(R.string.usdt__bridge_provider)) { BodySSB("Orchestra") } + bridge.destinationTx?.let { hash -> + SendCell( + caption = stringResource(R.string.usdt__destination_tx) + ) { SelectionContainer { BodyS(hash) } } + } + bridge.refundAmount?.let { amount -> + SendCell(caption = stringResource(R.string.usdt__deposit_refunded)) { + BodySSB(if (hideBalance) UiConstants.HIDE_BALANCE_SHORT else usdtFormatAmount(amount) + " USDT") + } + } + bridge.refundTx?.let { hash -> + SendCell(caption = stringResource(R.string.usdt__refund_tx)) { SelectionContainer { BodyS(hash) } } + } +} + +@Composable +private fun UsdtTransactionDetails(transfer: UsdtTransfer) { + val uri = LocalUriHandler.current + transfer.txHash?.let { txHash -> + SendCell( + caption = stringResource(R.string.wallet__activity_tx_id) + ) { SelectionContainer { BodyS(txHash) } } + if (transfer.destination != UsdtDestination.ARBITRUM && transfer.orchestra == null) { + SecondaryButton(text = stringResource(R.string.usdt__track_bridge), onClick = { + uri.openUri("https://layerzeroscan.com/tx/" + txHash) + }) + } + SecondaryButton(text = stringResource(R.string.wallet__activity_explore), onClick = { + uri.openUri("https://arbiscan.io/tx/" + txHash) + }) + } +} diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtDepositReceiveScreen.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtDepositReceiveScreen.kt new file mode 100644 index 0000000000..21e7b557e9 --- /dev/null +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtDepositReceiveScreen.kt @@ -0,0 +1,526 @@ +package to.bitkit.ui.screens.wallets.usdt + +import androidx.activity.compose.BackHandler +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.ColumnScope +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.text.selection.SelectionContainer +import androidx.compose.foundation.verticalScroll +import androidx.compose.material3.AlertDialog +import androidx.compose.material3.DropdownMenu +import androidx.compose.material3.DropdownMenuItem +import androidx.compose.material3.HorizontalDivider +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.runtime.DisposableEffect +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.testTag +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.unit.dp +import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel +import androidx.lifecycle.Lifecycle +import androidx.lifecycle.compose.LocalLifecycleOwner +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import androidx.lifecycle.repeatOnLifecycle +import com.synonym.bitkitcore.UsdtDepositDetail +import com.synonym.bitkitcore.UsdtDepositNetwork +import com.synonym.bitkitcore.UsdtException +import com.synonym.bitkitcore.usdtFormatAmount +import kotlinx.coroutines.delay +import kotlinx.coroutines.launch +import to.bitkit.R +import to.bitkit.env.Env +import to.bitkit.repositories.UsdtWalletState +import to.bitkit.ui.components.BodyS +import to.bitkit.ui.components.BodySSB +import to.bitkit.ui.components.Caption13Up +import to.bitkit.ui.components.FillHeight +import to.bitkit.ui.components.NumberPad +import to.bitkit.ui.components.NumberPadActionButton +import to.bitkit.ui.components.NumberPadAmountText +import to.bitkit.ui.components.NumberPadType +import to.bitkit.ui.components.PrimaryButton +import to.bitkit.ui.components.SecondaryButton +import to.bitkit.ui.components.SendCell +import to.bitkit.ui.components.TextInput +import to.bitkit.ui.components.UsdtAmountHeader +import to.bitkit.ui.components.VerticalSpacer +import to.bitkit.ui.scaffold.SheetTopBar +import to.bitkit.ui.screens.wallets.activity.components.ActivityRowSurface +import to.bitkit.ui.theme.Colors +import to.bitkit.ui.utils.NumberPadInputHandler +import java.text.NumberFormat +import java.util.Locale +import kotlin.time.Duration.Companion.seconds + +@Suppress("CyclomaticComplexMethod") +@Composable +internal fun ColumnScope.UsdtDepositReceiveScreen( + viewModel: UsdtViewModel, + onBack: () -> Unit, + onBlockingChange: (Boolean) -> Unit, + deposits: UsdtDepositViewModel = hiltViewModel(), +) { + val wallet by viewModel.wallet.collectAsStateWithLifecycle() + val settings by viewModel.settings.collectAsStateWithLifecycle() + val walletUi by viewModel.state.collectAsStateWithLifecycle() + val state by deposits.state.collectAsStateWithLifecycle() + var amount by remember { mutableStateOf("") } + var refundAddress by remember(state.detail?.deposit?.id) { mutableStateOf("") } + var approved by remember { mutableStateOf(null) } + var confirmation by remember { mutableStateOf(false) } + var authentication by remember { mutableStateOf(false) } + val scope = rememberCoroutineScope() + val lifecycle = LocalLifecycleOwner.current.lifecycle + val back = { + if (authentication) { + authentication = false + approved = null + } else if (!deposits.back()) onBack() + } + val refund = { + approved?.let { deposits.refund(it.id, it.offset, it.address, it.network) } + approved = null + } + LaunchedEffect(state.busy, authentication) { onBlockingChange(state.busy || authentication) } + DisposableEffect(Unit) { onDispose { onBlockingChange(false) } } + val pendingId = state.detail?.takeIf { + (it.order?.status ?: it.deposit.status) !in listOf("completed", "refunded") + }?.deposit?.id + DepositPolling(pendingId, lifecycle, { confirmation || authentication || approved != null }) { + deposits.detail(it) + } + BackHandler(onBack = back) + if (authentication) { + UsdtAuthentication( + useBiometrics = settings.isBiometricEnabled, + onCancel = { + authentication = false + approved = null + }, + onVerified = { + authentication = false + refund() + }, + ) + } else { + SheetTopBar( + titleText = stringResource( + if (state.history) R.string.usdt__deposit_history else R.string.usdt__receive_title + ), + onBack = back, + ) + VerticalSpacer(16.dp) + walletUi.error?.let { BodyS(stringResource(it), color = Colors.Brand) } + Content( + wallet = wallet, + receiveError = walletUi.refreshError, + state = state, + amount = amount, + refundAddress = refundAddress, + hideBalance = settings.hideBalance, + onNetwork = deposits::selectNetwork, + onAmount = { + if (amount != it) deposits.clearAmountError() + amount = it + }, + onRefundAddress = { refundAddress = it }, + onCreate = { deposits.prepare(amount) }, + onHistory = { deposits.history() }, + onMore = { state.nextOffset?.let { deposits.history(it) } }, + onDetail = { scope.launch { deposits.detail(it) } }, + onRefund = { if (!deposits.state.value.busy) confirmation = true }, + onRefresh = { deposits.selectNetwork(state.network) }, + ) + } + if (confirmation) { + RefundDialog( + network = state.detail?.deposit?.network.orEmpty() + "\n" + state.detail?.deposit?.id.orEmpty() + + "\n" + state.detail?.deposit?.amount.usdtText(settings.hideBalance), + address = refundAddress, + onCancel = { confirmation = false }, + onConfirm = { + confirmation = false + val approval = refundApproval(state, refundAddress) + if (approval != null) { + approved = approval + scope.launch { + try { + viewModel.readPaymentSettings { paymentSettings -> + if (approved != approval) return@readPaymentSettings + if (paymentSettings.isPinEnabled && paymentSettings.isPinForPaymentsEnabled) { + authentication = true + } else { + refund() + } + } + } finally { + if (!authentication && approved == approval) approved = null + } + } + } + }, + ) + } +} + +@Composable +private fun DepositPolling( + id: String?, + lifecycle: Lifecycle, + isPaused: () -> Boolean, + refresh: suspend (String) -> Unit +) { + LaunchedEffect(id, lifecycle, isPaused()) { + if (id == null || isPaused()) return@LaunchedEffect + lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) { + while (true) { + delay(10.seconds) + if (!isPaused()) refresh(id) + } + } + } +} + +private data class RefundApproval( + val id: String, + val offset: UInt, + val address: String, + val network: UsdtDepositNetwork, +) + +private fun refundApproval(state: DepositUiState, address: String): RefundApproval? { + val deposit = state.detail?.deposit ?: return null + val network = deposit.network.depositNetwork() ?: return null + return RefundApproval(deposit.id, state.offset, address, network) +} + +@Composable +private fun RefundDialog(network: String, address: String, onCancel: () -> Unit, onConfirm: () -> Unit) { + AlertDialog( + onDismissRequest = onCancel, + title = { Text(stringResource(R.string.usdt__deposit_refund)) }, + text = { + Text( + network.uppercase() + "\n" + address + "\n\n" + + stringResource(R.string.usdt__deposit_refund_note) + ) + }, + confirmButton = { TextButton(onClick = onConfirm) { Text(stringResource(R.string.usdt__deposit_refund)) } }, + dismissButton = { TextButton(onClick = onCancel) { Text(stringResource(R.string.common__cancel)) } }, + ) +} + +@Composable +private fun ColumnScope.Content( + wallet: UsdtWalletState, + receiveError: Int?, + state: DepositUiState, + amount: String, + refundAddress: String, + hideBalance: Boolean, + onNetwork: (UsdtDepositNetwork?) -> Unit, + onAmount: (String) -> Unit, + onRefundAddress: (String) -> Unit, + onCreate: () -> Unit, + onHistory: () -> Unit, + onMore: () -> Unit, + onDetail: (String) -> Unit, + onRefund: () -> Unit, + onRefresh: () -> Unit, +) { + if (state.history) { + DepositHistory(state, refundAddress, hideBalance, onRefundAddress, onRefund, onMore, onDetail, onHistory) + return + } + NetworkSelector(state, onNetwork, onHistory) + if (state.network == null) { + state.error?.let { BodyS(stringResource(it), color = Colors.White64) } + UsdtReceiveContent(wallet.address, wallet.receiveUri, error = receiveError) + } else if (state.address != null) { + val address = state.address + UsdtReceiveContent( + address.address, + address.uri, + null, + R.string.usdt__deposit_notice + ) { + DepositField(R.string.usdt__deposit_estimate, address.estimatedReceived.usdtText(false)) + DepositField( + R.string.usdt__deposit_cost, + if (address.amount >= address.estimatedReceived) { + (address.amount - address.estimatedReceived).usdtText(false) + } else { + "—" + } + ) + BodyS(stringResource(R.string.usdt__deposit_estimate_note), color = Colors.White64) + VerticalSpacer(16.dp) + DepositField( + R.string.usdt__deposit_limits, + (address.minUsdCents?.usdCents() ?: "—") + " – " + (address.maxUsdCents?.usdCents() ?: "—") + ) + BodyS(stringResource(R.string.usdt__deposit_limits_note), color = Colors.White64) + SecondaryButton(stringResource(R.string.usdt__deposit_refresh), onClick = onRefresh) + VerticalSpacer(16.dp) + } + } else { + DepositAmount(amount, state.busy, state.error, state.amountLimits, onAmount, onCreate) + } +} + +@Composable +private fun ColumnScope.DepositHistory( + state: DepositUiState, + refundAddress: String, + hideBalance: Boolean, + onRefundAddress: (String) -> Unit, + onRefund: () -> Unit, + onMore: () -> Unit, + onDetail: (String) -> Unit, + onHistory: () -> Unit, +) { + Column( + verticalArrangement = Arrangement.spacedBy(16.dp), + modifier = Modifier.weight(1f).verticalScroll(rememberScrollState()) + ) { + BodyS(stringResource(R.string.usdt__deposit_status_note), color = Colors.White64) + if (state.detail != null) { + DepositDetail(state.detail, refundAddress, hideBalance, state.busy, onRefundAddress, onRefund) + } else { + if (state.deposits.isEmpty()) { + BodyS( + stringResource(R.string.usdt__deposit_empty), + color = Colors.White64 + ) + } + state.deposits.forEach { deposit -> + ActivityRowSurface(onClick = { if (!state.busy) onDetail(deposit.id) }) { + Column(modifier = Modifier.weight(1f)) { + BodySSB(deposit.network.uppercase()) + BodyS(stringResource(depositStatus(deposit.status, deposit.code)), color = Colors.White64) + } + BodySSB(if (deposit.asset == "USDT") deposit.amount.usdtText(hideBalance) else deposit.asset) + } + } + if (state.nextOffset != null) { + SecondaryButton( + stringResource(R.string.usdt__deposit_more), + onClick = onMore, + enabled = !state.busy + ) + } + } + state.error?.let { BodyS(stringResource(it), color = Colors.Brand) } + state.message?.let { BodyS(stringResource(it), color = Colors.White64) } + } + VerticalSpacer(16.dp) + SecondaryButton( + stringResource(R.string.usdt__deposit_refresh), + onClick = onHistory, + enabled = !state.busy, + isLoading = state.busy + ) +} + +@Composable +private fun NetworkSelector( + state: DepositUiState, + onNetwork: (UsdtDepositNetwork?) -> Unit, + onHistory: () -> Unit, +) { + Row(horizontalArrangement = Arrangement.SpaceBetween, modifier = Modifier.fillMaxWidth()) { + var menu by remember { mutableStateOf(false) } + Box { + NumberPadActionButton( + state.network?.label ?: "Arbitrum One", + onClick = { menu = true }, + enabled = !state.busy, + color = Colors.Green, + modifier = Modifier.testTag("UsdtReceiveNetwork") + ) + DropdownMenu( + expanded = menu, + onDismissRequest = { menu = false }, + containerColor = Colors.Gray6, + ) { + DropdownMenuItem(text = { BodySSB("Arbitrum One") }, onClick = { + menu = false + onNetwork(null) + }) + state.networks.forEach { network -> + DropdownMenuItem( + text = { BodySSB(network.label) }, + onClick = { + menu = false + onNetwork(network) + } + ) + } + } + } + if (Env.usdtDepositsUrl != null) { + TextButton( + onClick = onHistory, + enabled = !state.busy + ) { BodySSB(stringResource(R.string.usdt__activity), color = Colors.Green) } + } + } + VerticalSpacer(16.dp) +} + +@Composable +private fun ColumnScope.DepositAmount( + amount: String, + busy: Boolean, + error: Int?, + limits: UsdtException.DepositAmountOutOfRange?, + onAmount: (String) -> Unit, + onCreate: () -> Unit, +) { + Caption13Up(stringResource(R.string.usdt__deposit_amount)) + VerticalSpacer(12.dp) + NumberPadAmountText(amount.ifEmpty { "0" }, "₮") + FillHeight() + val message = when { + limits != null && (limits.minUsdCents != null || limits.maxUsdCents != null) -> + stringResource(R.string.usdt__deposit_limits) + ": " + + (limits.minUsdCents?.usdCents() ?: "—") + " – " + (limits.maxUsdCents?.usdCents() ?: "—") + error != null -> stringResource(error) + else -> stringResource(R.string.usdt__deposit_fee_note) + } + BodyS(message, color = if (error == null) Colors.White64 else Colors.Brand) + VerticalSpacer(16.dp) + HorizontalDivider() + NumberPad( + type = NumberPadType.DECIMAL, + enabled = !busy, + onDeleteLongPress = { onAmount("") }, + onPress = { onAmount(NumberPadInputHandler.handleInput(it, amount, maxLength = 21, maxDecimals = 6)) }, + ) + PrimaryButton( + stringResource(R.string.usdt__deposit_create), + onClick = onCreate, + enabled = !busy && amount.isNotEmpty(), + isLoading = busy, + modifier = Modifier.testTag("UsdtDepositCreate") + ) +} + +@Composable +private fun DepositDetail( + detail: UsdtDepositDetail, + address: String, + hideBalance: Boolean, + busy: Boolean, + onAddress: (String) -> Unit, + onRefund: () -> Unit +) { + val deposit = detail.deposit + val status = detail.order?.status ?: deposit.status + val code = detail.statusCode + if (deposit.asset == "USDT") { + UsdtAmountHeader( + deposit.amount?.let { usdtFormatAmount(it) } ?: "—", + deposit.network.uppercase(), + hideBalance = hideBalance + ) + } else { + BodySSB(deposit.asset + " · " + deposit.network.uppercase()) + } + DepositField(R.string.wallet__activity_status, stringResource(detail.statusResource())) + DepositField(R.string.usdt__deposit_reference, deposit.id) + DepositField(R.string.wallet__activity_tx_id, deposit.sourceTx) + code?.let { BodyS(it, color = Colors.White64) } + DepositSettlement(detail, hideBalance) + if (deposit.asset != "USDT" || deposit.network.depositNetwork() == null) { + BodyS(stringResource(R.string.usdt__deposit_wrong_asset), color = Colors.White64) + } else if (status !in listOf("completed", "refunded", "refunding", "refund_requested")) { + BodyS(stringResource(R.string.usdt__deposit_refund_note), color = Colors.White64) + TextInput( + value = address, + onValueChange = { if (!busy) onAddress(it) }, + placeholder = stringResource(R.string.usdt__deposit_refund_address), + modifier = Modifier.testTag("UsdtRefundAddress") + ) + SecondaryButton( + stringResource(R.string.usdt__deposit_refund), + onClick = onRefund, + enabled = !busy && address.isNotBlank(), + isLoading = busy, + modifier = Modifier.testTag("UsdtDepositRefund") + ) + } +} + +@Composable +private fun DepositSettlement(detail: UsdtDepositDetail, hideBalance: Boolean) { + val order = detail.order?.takeUnless { it.status == "refunded" } + val deposit = detail.deposit + order?.amountOut?.let { DepositField(R.string.usdt__deposit_batch, it.usdtText(hideBalance)) } + order?.destinationTx?.let { + SendCell(caption = stringResource(R.string.wallet__activity_tx_id) + " · Arbitrum One") { + SelectionContainer { BodySSB(it) } + } + } + (detail.order?.refundTx ?: deposit.refundTx)?.let { DepositField(R.string.usdt__deposit_refund, it) } + val sent = order?.amountIn + val received = order?.amountOut + if (sent != null && received != null && sent >= received) { + DepositField(R.string.usdt__deposit_cost, (sent - received).usdtText(hideBalance)) + } +} + +@Composable +private fun DepositField(title: Int, value: String) { + SendCell(caption = stringResource(title)) { SelectionContainer { BodySSB(value) } } +} + +private val UsdtDepositNetwork.label: String + get() = when (this) { + UsdtDepositNetwork.ETHEREUM -> "Ethereum" + UsdtDepositNetwork.SOLANA -> "Solana" + UsdtDepositNetwork.POLYGON -> "Polygon" + UsdtDepositNetwork.BSC -> "BNB Smart Chain" + UsdtDepositNetwork.BASE -> "Base" + UsdtDepositNetwork.TRON -> "Tron" + } +internal fun String.depositNetwork(): UsdtDepositNetwork? = + UsdtDepositNetwork.entries.firstOrNull { it.name.equals(this, ignoreCase = true) } +private fun ULong?.usdtText(hidden: Boolean) = ( + if (hidden) { + "•••••" + } else { + this?.let { + usdtFormatAmount(it) + } ?: "—" + } + ) + " USDT" +private fun String.usdCents(locale: Locale = Locale.getDefault()): String = toULongOrNull()?.let { + val whole = NumberFormat.getIntegerInstance(locale).format((it / 100u).toLong()) + "$$whole.${(it % 100u).toString().padStart(2, '0')}" +} ?: "—" +private fun depositStatus(status: String, code: String?): Int = when { + code != null -> R.string.usdt__deposit_needs_attention + status == "completed" -> R.string.usdt__confirmed + status == "refunded" -> R.string.usdt__deposit_refunded + status in listOf("refunding", "refund_requested") -> R.string.usdt__deposit_refunding + status in listOf("pending", "processing") -> R.string.usdt__pending + else -> R.string.usdt__deposit_needs_attention +} + +internal val UsdtDepositDetail.statusCode: String? + get() = if (order != null) order?.code else deposit.code + +internal fun UsdtDepositDetail.statusResource(): Int = depositStatus(order?.status ?: deposit.status, statusCode) diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtDepositViewModel.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtDepositViewModel.kt new file mode 100644 index 0000000000..af8f8ef1ef --- /dev/null +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtDepositViewModel.kt @@ -0,0 +1,159 @@ +package to.bitkit.ui.screens.wallets.usdt + +import androidx.compose.runtime.Stable +import androidx.lifecycle.ViewModel +import androidx.lifecycle.viewModelScope +import com.synonym.bitkitcore.UsdtDeposit +import com.synonym.bitkitcore.UsdtDepositAddress +import com.synonym.bitkitcore.UsdtDepositDetail +import com.synonym.bitkitcore.UsdtDepositNetwork +import com.synonym.bitkitcore.UsdtException +import dagger.hilt.android.lifecycle.HiltViewModel +import kotlinx.collections.immutable.ImmutableList +import kotlinx.collections.immutable.persistentListOf +import kotlinx.collections.immutable.toImmutableList +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.update +import kotlinx.coroutines.launch +import to.bitkit.R +import to.bitkit.repositories.UsdtDepositRepo +import javax.inject.Inject + +@HiltViewModel +class UsdtDepositViewModel @Inject constructor(private val repo: UsdtDepositRepo) : ViewModel() { + private val _state = MutableStateFlow(DepositUiState()) + val state = _state.asStateFlow() + private val pageOffsets = mutableMapOf() + + init { + viewModelScope.launch { + repo.depositNetworks().onSuccess { networks -> _state.update { it.copy(networks = networks) } } + .onFailure { _state.update { it.copy(error = R.string.usdt__deposit_unavailable) } } + } + } + + fun selectNetwork(network: UsdtDepositNetwork?) { + if (!_state.value.busy) { + _state.update { it.copy(network = network, address = null, error = null, amountLimits = null) } + } + } + + fun clearAmountError() { + _state.update { it.copy(error = null, amountLimits = null) } + } + + fun prepare(amount: String) = viewModelScope.launch { + val network = _state.value.network ?: return@launch + operation { + repo.prepareDeposit(network, amount).onSuccess { address -> _state.update { it.copy(address = address) } } + } + } + + fun history(offset: UInt = 0u) = viewModelScope.launch { + operation { + repo.depositHistory(offset).onSuccess { page -> + if (offset == 0u) pageOffsets.clear() + page.deposits.forEach { pageOffsets[it.id] = offset } + _state.update { + it.copy( + history = true, + detail = null, + deposits = ( + if (offset == 0u) { + page.deposits + } else { + val updatedIds = page.deposits.map { deposit -> deposit.id }.toSet() + it.deposits.filterNot { deposit -> deposit.id in updatedIds } + page.deposits + } + ).toImmutableList(), + offset = offset, + nextOffset = page.nextOffset, + message = null + ) + } + } + } + } + + suspend fun detail(id: String) { + operation { + repo.depositDetail( + id, + pageOffsets[id] ?: _state.value.offset + ).onSuccess { detail -> _state.update { it.copy(detail = detail, offset = pageOffsets[id] ?: it.offset) } } + } + } + + fun back(): Boolean { + if (_state.value.busy) return true + return when { + _state.value.detail != null -> { + _state.update { it.copy(detail = null, message = null) } + true + } + _state.value.history -> { + _state.update { it.copy(history = false, error = null, amountLimits = null) } + true + } + else -> false + } + } + + fun refund(id: String, offset: UInt, address: String, network: UsdtDepositNetwork) = viewModelScope.launch { + val detail = _state.value.detail ?: return@launch + if (detail.deposit.id != id || (detail.order?.status ?: detail.deposit.status) in + listOf("completed", "refunded", "refunding", "refund_requested") + ) { + return@launch + } + operation { + repo.refundDeposit(id, offset, address, network).onSuccess { + _state.update { + it.copy( + detail = it.detail?.let { detail -> + detail.copy( + deposit = detail.deposit.copy(status = "refund_requested", code = null), + order = detail.order?.copy(status = "refund_requested", code = null), + ) + }, + message = R.string.usdt__deposit_refund_requested, + ) + } + } + } + } + + private suspend fun operation(block: suspend () -> Result<*>) { + if (_state.value.busy) return + _state.update { it.copy(busy = true, error = null, amountLimits = null) } + try { + block().onFailure { error -> + _state.update { + it.copy( + error = error.messageResource(), + amountLimits = error as? UsdtException.DepositAmountOutOfRange, + ) + } + } + } finally { + _state.update { it.copy(busy = false) } + } + } +} + +@Stable +data class DepositUiState( + val networks: ImmutableList = persistentListOf(), + val network: UsdtDepositNetwork? = null, + val address: UsdtDepositAddress? = null, + val history: Boolean = false, + val deposits: ImmutableList = persistentListOf(), + val offset: UInt = 0u, + val nextOffset: UInt? = null, + val detail: UsdtDepositDetail? = null, + val busy: Boolean = false, + val error: Int? = null, + val amountLimits: UsdtException.DepositAmountOutOfRange? = null, + val message: Int? = null, +) diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtReceiveContent.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtReceiveContent.kt new file mode 100644 index 0000000000..6fb2e9a32d --- /dev/null +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtReceiveContent.kt @@ -0,0 +1,106 @@ +package to.bitkit.ui.screens.wallets.usdt + +import androidx.compose.foundation.layout.BoxWithConstraints +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.ColumnScope +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.verticalScroll +import androidx.compose.material3.Icon +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.saveable.rememberSaveable +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.testTag +import androidx.compose.ui.res.painterResource +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import to.bitkit.R +import to.bitkit.ui.components.BodyS +import to.bitkit.ui.components.ButtonSize +import to.bitkit.ui.components.GradientCircularProgressIndicator +import to.bitkit.ui.components.PrimaryButton +import to.bitkit.ui.components.TertiaryButton +import to.bitkit.ui.components.VerticalSpacer +import to.bitkit.ui.screens.wallets.receive.CopyAddressCard +import to.bitkit.ui.screens.wallets.receive.CopyAddressType +import to.bitkit.ui.screens.wallets.receive.ReceiveQrView +import to.bitkit.ui.theme.Colors + +@Composable +internal fun ColumnScope.UsdtReceiveContent( + address: String, + uri: String, + error: Int?, + warning: Int = R.string.usdt__receive_warning, + details: @Composable () -> Unit = {}, +) { + var showDetails by rememberSaveable { mutableStateOf(false) } + Column(modifier = Modifier.weight(1f).verticalScroll(rememberScrollState())) { + if (uri.isNotEmpty()) { + if (showDetails) { + CopyAddressCard( + title = stringResource(R.string.usdt__address), + address = address, + type = CopyAddressType.ONCHAIN, + onClickEditInvoice = null, + testTag = "UsdtReceiveAddress", + accentColor = Colors.Green, + ) + } else { + BoxWithConstraints(modifier = Modifier.fillMaxWidth()) { + ReceiveQrView( + uri = uri, + copyText = address, + qrLogoPainter = null, + onClickEditInvoice = null, + accentColor = Colors.Green, + shareContent = uri, + modifier = Modifier.fillMaxWidth().height(maxWidth + ButtonSize.Small.height + 32.dp) + ) + } + VerticalSpacer(16.dp) + BodyS( + address, + color = Colors.White64, + maxLines = 1, + overflow = TextOverflow.MiddleEllipsis, + modifier = Modifier.testTag("UsdtReceiveAddress") + ) + } + } else if (error != null) { + BodyS(stringResource(error), color = Colors.Brand) + } else { + GradientCircularProgressIndicator(modifier = Modifier.size(24.dp)) + } + VerticalSpacer(16.dp) + details() + BodyS(stringResource(warning), color = Colors.White64) + } + if (showDetails) { + PrimaryButton( + text = stringResource(R.string.wallet__receive_show_qr), + icon = { + Icon( + painter = painterResource(R.drawable.ic_qr_purple), + contentDescription = null, + tint = Colors.White, + modifier = Modifier.size(16.dp) + ) + }, + onClick = { showDetails = false }, + modifier = Modifier.testTag("UsdtReceiveDetails") + ) + } else { + TertiaryButton( + text = stringResource(R.string.common__show_details), + onClick = { showDetails = true }, + modifier = Modifier.testTag("UsdtReceiveDetails") + ) + } +} diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtSendContent.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtSendContent.kt new file mode 100644 index 0000000000..136449957c --- /dev/null +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtSendContent.kt @@ -0,0 +1,543 @@ +package to.bitkit.ui.screens.wallets.usdt + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.ColumnScope +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.heightIn +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.text.selection.SelectionContainer +import androidx.compose.foundation.verticalScroll +import androidx.compose.material3.DropdownMenu +import androidx.compose.material3.DropdownMenuItem +import androidx.compose.material3.HorizontalDivider +import androidx.compose.material3.Icon +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableFloatStateOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.saveable.rememberSaveable +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.focus.FocusRequester +import androidx.compose.ui.focus.focusRequester +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.platform.LocalInspectionMode +import androidx.compose.ui.platform.testTag +import androidx.compose.ui.res.painterResource +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.tooling.preview.Preview +import androidx.compose.ui.unit.dp +import com.synonym.bitkitcore.UsdtBridgeProvider +import com.synonym.bitkitcore.UsdtDestination +import com.synonym.bitkitcore.UsdtQuote +import com.synonym.bitkitcore.UsdtTransferStatus +import com.synonym.bitkitcore.usdtFormatAmount +import kotlinx.collections.immutable.ImmutableList +import kotlinx.collections.immutable.toImmutableList +import to.bitkit.R +import to.bitkit.env.Env +import to.bitkit.ext.getClipboardText +import to.bitkit.models.NewTransactionSheetDetails +import to.bitkit.models.NewTransactionSheetDirection +import to.bitkit.models.NewTransactionSheetType +import to.bitkit.repositories.UsdtWalletState +import to.bitkit.ui.components.BodyM +import to.bitkit.ui.components.BodyS +import to.bitkit.ui.components.BodySSB +import to.bitkit.ui.components.BottomSheetPreview +import to.bitkit.ui.components.ButtonSize +import to.bitkit.ui.components.Caption13Up +import to.bitkit.ui.components.FillHeight +import to.bitkit.ui.components.NumberPad +import to.bitkit.ui.components.NumberPadActionButton +import to.bitkit.ui.components.NumberPadAmountText +import to.bitkit.ui.components.NumberPadType +import to.bitkit.ui.components.PaymentAddressInput +import to.bitkit.ui.components.PaymentReviewIllustration +import to.bitkit.ui.components.PrimaryButton +import to.bitkit.ui.components.RectangleButton +import to.bitkit.ui.components.SecondaryButton +import to.bitkit.ui.components.SendCell +import to.bitkit.ui.components.SwipeToConfirm +import to.bitkit.ui.components.UsdtAmountHeader +import to.bitkit.ui.components.VerticalSpacer +import to.bitkit.ui.scaffold.SheetTopBar +import to.bitkit.ui.screens.scanner.QrScanningScreen +import to.bitkit.ui.screens.wallets.send.HourglassAnimation +import to.bitkit.ui.shared.UiConstants +import to.bitkit.ui.shared.modifiers.sheetHeight +import to.bitkit.ui.shared.util.gradientBackground +import to.bitkit.ui.sheets.NewTransactionSheetView +import to.bitkit.ui.theme.AppThemeSurface +import to.bitkit.ui.theme.Colors +import to.bitkit.ui.utils.NumberPadInputHandler + +@Suppress("CyclomaticComplexMethod") +@Composable +internal fun ColumnScope.UsdtPaymentContent( + wallet: UsdtWalletState, + state: UsdtSendState, + page: UsdtPage, + recipient: String, + amount: String, + destination: UsdtDestination, + onRecipientChange: (String) -> Unit, + onAmountChange: (String) -> Unit, + onRecipientContinue: (String) -> Unit, + onPageChange: (UsdtPage) -> Unit, + onBack: () -> Unit, + onReview: () -> Unit, + onConfirm: () -> Unit, + onDone: () -> Unit, + onDetails: () -> Unit = {}, + hideBalance: Boolean = false, + amountEditable: Boolean = true, + onDestinationChange: ((UsdtDestination) -> Unit)? = null, + destinations: ImmutableList = Env.usdtDestinations.toImmutableList(), +) { + val showSubmitted = state.submitted && !state.busy + val quote = state.quote + val status = wallet.transfers.firstOrNull { it.id == quote?.id }?.status + if (showSubmitted && quote != null && status == UsdtTransferStatus.CONFIRMED) { + NewTransactionSheetView( + details = NewTransactionSheetDetails( + type = NewTransactionSheetType.ONCHAIN, + direction = NewTransactionSheetDirection.SENT, + activityId = quote.id, + usdtAmount = quote.amount, + ), + onCloseClick = onDone, + onDetailClick = onDetails, + usdtNetwork = quote.destination.label, + hideBalance = hideBalance, + modifier = Modifier.fillMaxSize().testTag("UsdtSendSuccess") + ) + return + } + val bridgeNeedsAttention = status == UsdtTransferStatus.BRIDGE_NEEDS_ATTENTION || + status == UsdtTransferStatus.BRIDGE_FAILED + val failed = status == UsdtTransferStatus.FAILED || status == UsdtTransferStatus.REPLACED + val title = when { + showSubmitted && status == UsdtTransferStatus.BRIDGE_REFUNDED -> R.string.usdt__deposit_refunded + showSubmitted && bridgeNeedsAttention -> R.string.usdt__bridge_attention + showSubmitted && failed -> R.string.wallet__send_error_tx_failed + showSubmitted -> R.string.usdt__submitted + quote != null -> R.string.wallet__send_review + page == UsdtPage.AMOUNT -> R.string.usdt__amount + else -> R.string.usdt__send_title + } + SheetTopBar(stringResource(title), onBack = onBack.takeUnless { showSubmitted || state.busy }) + VerticalSpacer(16.dp) + when { + showSubmitted -> UsdtSubmittedContent( + quote, + failed, + bridgeNeedsAttention, + status == UsdtTransferStatus.BRIDGE_REFUNDED, + onDetails, + onDone + ) + quote != null -> UsdtConfirmation(quote, state, onConfirm, onEditAmount = { onPageChange(UsdtPage.AMOUNT) }) + page == UsdtPage.AMOUNT -> UsdtAmountContent( + amount, + destination, + wallet, + state, + onAmountChange, + onReview, + hideBalance, + amountEditable + ) + page == UsdtPage.MANUAL -> UsdtManualContent( + recipient, + destination, + onRecipientChange, + onRecipientContinue, + state.error, + onDestinationChange, + destinations + ) + else -> UsdtRecipientContent( + destination, + onRecipientContinue, + onPageChange, + state.error, + onDestinationChange, + destinations + ) + } +} + +@Composable +private fun ColumnScope.UsdtSubmittedContent( + quote: UsdtQuote?, + failed: Boolean, + needsAttention: Boolean, + refunded: Boolean, + onDetails: () -> Unit, + onDone: () -> Unit, +) { + quote?.let { UsdtAmountHeader(usdtFormatAmount(it.amount), it.destination.label) } + VerticalSpacer(32.dp) + BodyM( + stringResource( + when { + refunded -> R.string.usdt__bridge_refunded_description + needsAttention -> R.string.usdt__bridge_attention + failed -> R.string.usdt__send_failed_description + quote?.destination == UsdtDestination.ARBITRUM -> R.string.usdt__submitted_description + else -> R.string.usdt__bridge_submitted_description + } + ), + color = Colors.White64 + ) + FillHeight() + if (!failed && !needsAttention && !refunded) { + HourglassAnimation( + modifier = Modifier.align(Alignment.CenterHorizontally) + ) + } + FillHeight() + Row(horizontalArrangement = Arrangement.spacedBy(16.dp)) { + SecondaryButton( + text = stringResource(R.string.wallet__send_details), + onClick = onDetails, + modifier = Modifier.weight(1f) + ) + PrimaryButton( + text = stringResource(R.string.common__close), + onClick = onDone, + modifier = Modifier.weight(1f) + ) + } +} + +@Composable +private fun UsdtNetwork( + destination: UsdtDestination, + onChange: ((UsdtDestination) -> Unit)?, + destinations: ImmutableList +) { + SendCell(caption = stringResource(R.string.usdt__destination)) { + if (onChange == null || destinations.size == 1) { + BodySSB(destination.label, modifier = Modifier.height(28.dp).testTag("UsdtNetwork")) + } else { + var expanded by remember { mutableStateOf(false) } + Box { + NumberPadActionButton( + destination.label, + onClick = { expanded = true }, + color = Colors.Green, + modifier = Modifier.testTag("UsdtNetwork") + ) + DropdownMenu( + expanded = expanded, + onDismissRequest = { expanded = false }, + containerColor = Colors.Gray6, + ) { + destinations.forEach { network -> + DropdownMenuItem(text = { BodySSB(network.label) }, onClick = { + expanded = false + onChange(network) + }) + } + } + } + } + } +} + +@Composable +private fun UsdtRecipientContent( + destination: UsdtDestination, + onRecipientContinue: (String) -> Unit, + onPageChange: (UsdtPage) -> Unit, + error: Int?, + onDestinationChange: ((UsdtDestination) -> Unit)?, + destinations: ImmutableList, +) { + val context = LocalContext.current + var emptyClipboard by remember { mutableStateOf(false) } + Column(verticalArrangement = Arrangement.spacedBy(8.dp), modifier = Modifier.fillMaxSize()) { + UsdtNetwork(destination, onDestinationChange, destinations) + if (!LocalInspectionMode.current) { + QrScanningScreen( + onScanSuccess = { it.text?.trim()?.let(onRecipientContinue) }, + modifier = Modifier.weight(1f) + ) + } else { FillHeight() } + RectangleButton( + label = stringResource(R.string.wallet__payment_request_paste), + icon = R.drawable.ic_clipboard_text, + iconTint = Colors.Green, + modifier = Modifier.testTag("UsdtPaste") + ) { + val value = context.getClipboardText()?.trim() + if (value.isNullOrBlank()) { + emptyClipboard = true + } else { + emptyClipboard = false + onRecipientContinue(value) + } + } + RectangleButton( + label = stringResource(R.string.wallet__recipient_manual), + icon = R.drawable.ic_pencil_simple, + iconTint = Colors.Green, + modifier = Modifier.testTag("UsdtManual") + ) { onPageChange(UsdtPage.MANUAL) } + error?.let { + BodyS( + stringResource(it), + color = Colors.Brand, + modifier = Modifier.testTag("UsdtRecipientError") + ) + } + if (emptyClipboard) BodyS(stringResource(R.string.wallet__send_clipboard_empty_text), color = Colors.Brand) + BodyS(stringResource(R.string.usdt__network_warning), color = Colors.White64) + } +} + +@Composable +private fun UsdtManualContent( + recipient: String, + destination: UsdtDestination, + onRecipientChange: (String) -> Unit, + onRecipientContinue: (String) -> Unit, + error: Int?, + onDestinationChange: ((UsdtDestination) -> Unit)?, + destinations: ImmutableList, +) { + val focus = remember { FocusRequester() } + LaunchedEffect(Unit) { focus.requestFocus() } + Column(modifier = Modifier.fillMaxSize()) { + UsdtNetwork(destination, onDestinationChange, destinations) + VerticalSpacer(16.dp) + Caption13Up(stringResource(R.string.wallet__send_to), color = Colors.White64) + VerticalSpacer(8.dp) + PaymentAddressInput( + value = recipient, + onValueChange = onRecipientChange, + placeholder = stringResource(R.string.usdt__address), + modifier = Modifier.fillMaxWidth().weight(1f).focusRequester(focus).testTag("UsdtRecipient") + ) + VerticalSpacer(16.dp) + error?.let { + BodyS(stringResource(it), color = Colors.Brand, modifier = Modifier.testTag("UsdtRecipientError")) + VerticalSpacer(16.dp) + } + PrimaryButton( + text = stringResource(R.string.common__continue), + enabled = recipient.isNotBlank(), + onClick = { onRecipientContinue(recipient) }, + modifier = Modifier.testTag("UsdtRecipientContinue") + ) + } +} + +@Composable +private fun UsdtAmountContent( + amount: String, + destination: UsdtDestination, + wallet: UsdtWalletState, + state: UsdtSendState, + onAmountChange: (String) -> Unit, + onReview: () -> Unit, + hideBalance: Boolean, + amountEditable: Boolean, +) { + Column(modifier = Modifier.fillMaxSize()) { + Caption13Up("USDT · " + destination.label, color = Colors.White64) + VerticalSpacer(8.dp) + NumberPadAmountText(value = amount.ifEmpty { "0" }, symbol = "₮", modifier = Modifier.testTag("UsdtAmount")) + FillHeight() + state.error?.let { + BodyS(stringResource(it), color = Colors.Brand, modifier = Modifier.testTag("UsdtError")) + VerticalSpacer(16.dp) + } + Row(verticalAlignment = Alignment.Bottom) { + Column(modifier = Modifier.weight(1f)) { + Caption13Up(stringResource(R.string.usdt__balance), color = Colors.White64) + VerticalSpacer(4.dp) + BodySSB( + ( + if (hideBalance) { + UiConstants.HIDE_BALANCE_SHORT + } else { + wallet.balance?.let { + usdtFormatAmount(it) + } ?: "—" + } + ) + " USDT" + ) + } + NumberPadActionButton(text = "USDT", color = Colors.Green, enabled = false, onClick = {}) + } + VerticalSpacer(12.dp) + HorizontalDivider() + NumberPad( + type = NumberPadType.DECIMAL, + enabled = !state.busy && amountEditable, + onDeleteLongPress = { onAmountChange("") }, + onPress = { key -> + onAmountChange(NumberPadInputHandler.handleInput(key, amount, maxLength = 21, maxDecimals = 6)) + }, + ) + VerticalSpacer(16.dp) + PrimaryButton( + text = stringResource(R.string.common__continue), + onClick = onReview, + enabled = amount.isNotEmpty(), + isLoading = state.busy, + modifier = Modifier.testTag("UsdtReview") + ) + } +} + +@Composable +private fun UsdtConfirmation(quote: UsdtQuote, state: UsdtSendState, onConfirm: () -> Unit, onEditAmount: () -> Unit) { + var showDetails by rememberSaveable(quote.id) { mutableStateOf(false) } + val swipeProgress = remember { mutableFloatStateOf(0f) } + Column(modifier = Modifier.fillMaxSize()) { + Column(modifier = Modifier.weight(1f).verticalScroll(rememberScrollState())) { + UsdtAmountHeader( + usdtFormatAmount(quote.amount), + quote.destination.label, + onClick = { if (!state.busy) onEditAmount() } + ) + VerticalSpacer(32.dp) + if (showDetails) { + UsdtQuoteDetails(quote) + } else if (quote.destination == UsdtDestination.ARBITRUM) { + PaymentReviewIllustration( + swipeProgress = { swipeProgress.floatValue }, + modifier = Modifier.heightIn(max = 220.dp) + ) + } + VerticalSpacer(16.dp) + if (quote.destination != UsdtDestination.ARBITRUM) { + SendCell( + caption = stringResource( + if (quote.bridgeProvider == UsdtBridgeProvider.ORCHESTRA) { + R.string.usdt__expected_amount + } else { + R.string.usdt__recipient_gets + } + ) + ) { + BodySSB(usdtFormatAmount(quote.receivedAmount) + " USDT") + } + VerticalSpacer(16.dp) + if (quote.bridgeProvider == UsdtBridgeProvider.ORCHESTRA) { + SendCell(caption = stringResource(R.string.usdt__bridge_deducted_fee)) { + BodySSB(usdtFormatAmount(quote.amount - minOf(quote.amount, quote.receivedAmount)) + " USDT") + } + VerticalSpacer(16.dp) + } + } + SendCell( + caption = stringResource(R.string.usdt__maximum_fee) + ) { BodySSB(usdtFormatAmount(quote.maximumFee) + " USDT") } + VerticalSpacer(12.dp) + if (quote.destination != UsdtDestination.ARBITRUM) { + SendCell( + caption = stringResource(R.string.usdt__maximum_total) + ) { BodySSB(usdtFormatAmount(quote.amount + quote.maximumFee) + " USDT") } + VerticalSpacer(12.dp) + } + BodyS( + stringResource( + if (quote.bridgeProvider == UsdtBridgeProvider.ORCHESTRA) { + R.string.usdt__bridge_estimate_note + } else { + R.string.usdt__fee_note + } + ), + color = Colors.White64 + ) + state.error?.let { + BodyS( + stringResource(it), + color = Colors.Brand, + modifier = Modifier.testTag("UsdtError") + ) + } + } + PrimaryButton( + text = stringResource(if (showDetails) R.string.common__hide_details else R.string.common__show_details), + size = ButtonSize.Small, + onClick = { showDetails = !showDetails }, + fullWidth = false, + color = Colors.Gray65, + enableGradient = false, + icon = { + Icon( + painterResource(if (showDetails) R.drawable.ic_eye_slash else R.drawable.ic_coins), + null, + tint = Colors.Green, + modifier = Modifier.size(16.dp) + ) + }, + modifier = Modifier.align( + Alignment.CenterHorizontally + ).padding(vertical = 24.dp).testTag("UsdtReviewDetails") + ) + SwipeToConfirm( + text = stringResource(R.string.wallet__send_swipe), + color = Colors.Green, + onConfirm = onConfirm, + enabled = !state.busy, + loading = state.busy, + confirmed = state.busy || state.authenticationRequired, + progress = swipeProgress, + modifier = Modifier.fillMaxWidth().testTag("UsdtConfirm") + ) + } +} + +@Composable +private fun UsdtQuoteDetails(quote: UsdtQuote) { + Row(horizontalArrangement = Arrangement.spacedBy(16.dp)) { + SendCell(caption = stringResource(R.string.wallet__send_from), modifier = Modifier.weight(1f)) { + NumberPadActionButton(text = "USDT", color = Colors.Green, enabled = false, onClick = {}) + } + SendCell(caption = stringResource(R.string.usdt__destination), modifier = Modifier.weight(1f)) { + BodySSB(quote.destination.label, modifier = Modifier.height(28.dp)) + } + } + VerticalSpacer(16.dp) + SendCell( + caption = stringResource(R.string.wallet__send_to) + ) { SelectionContainer { BodySSB(quote.recipient) } } + VerticalSpacer(16.dp) + quote.bridgeProvider?.let { provider -> + SendCell(caption = stringResource(R.string.usdt__bridge_provider)) { + BodySSB(if (provider == UsdtBridgeProvider.ORCHESTRA) "Orchestra" else "USDT0") + } + } +} + +@Preview +@Composable +private fun Preview2() { + AppThemeSurface { + BottomSheetPreview { + Column(modifier = Modifier.sheetHeight().gradientBackground().padding(horizontal = 16.dp)) { + UsdtPaymentContent( + UsdtWalletState(), UsdtSendState(), UsdtPage.AMOUNT, "", "125", UsdtDestination.ARBITRUM, + {}, {}, {}, {}, {}, {}, {}, {} + ) + } + } + } +} diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtViewModel.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtViewModel.kt new file mode 100644 index 0000000000..59a40743e7 --- /dev/null +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtViewModel.kt @@ -0,0 +1,249 @@ +package to.bitkit.ui.screens.wallets.usdt + +import androidx.annotation.StringRes +import androidx.compose.runtime.Stable +import androidx.lifecycle.ViewModel +import androidx.lifecycle.viewModelScope +import com.synonym.bitkitcore.UsdtDestination +import com.synonym.bitkitcore.UsdtException +import com.synonym.bitkitcore.UsdtPaymentRequest +import com.synonym.bitkitcore.UsdtQuote +import dagger.hilt.android.lifecycle.HiltViewModel +import kotlinx.collections.immutable.ImmutableList +import kotlinx.collections.immutable.persistentListOf +import kotlinx.collections.immutable.toImmutableList +import kotlinx.coroutines.CancellationException +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.SharingStarted +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.catch +import kotlinx.coroutines.flow.first +import kotlinx.coroutines.flow.stateIn +import kotlinx.coroutines.flow.update +import kotlinx.coroutines.launch +import to.bitkit.R +import to.bitkit.data.SettingsData +import to.bitkit.data.SettingsStore +import to.bitkit.ext.runSuspendCatching +import to.bitkit.repositories.UsdtRepo +import to.bitkit.repositories.parseUsdtPaymentRequest +import to.bitkit.utils.Logger +import to.bitkit.viewmodels.SanityWarning +import javax.inject.Inject + +@HiltViewModel +class UsdtViewModel @Inject constructor( + private val repo: UsdtRepo, + private val settingsStore: SettingsStore, +) : ViewModel() { + companion object { + private const val TAG = "UsdtViewModel" + } + + val destinations = kotlinx.coroutines.flow.flow { + repo.sendDestinations() + .onSuccess { emit(it) } + .onFailure { Logger.warn("Could not load USDT bridge destinations", it, context = TAG) } + }.stateIn( + viewModelScope, + SharingStarted.WhileSubscribed(5000), + to.bitkit.env.Env.usdtDestinations.toImmutableList() + ) + + val wallet = repo.state + val receivedTxs = repo.receivedTxs + val settings = settingsStore.data.catch { + if (it is CancellationException) throw it + settingsReadFailed(it) + emit(SettingsData(hideBalance = true)) + }.stateIn( + viewModelScope, + SharingStarted.WhileSubscribed(5000), + SettingsData(hideBalance = true) + ) + var sendPayment: (suspend (UsdtQuote) -> Unit)? = null + private val _state = MutableStateFlow(UsdtSendState()) + val state = _state.asStateFlow() + + var isSendPresented: Boolean + get() = repo.isSendPresented + set(value) { repo.isSendPresented = value } + + suspend fun refresh(history: Boolean = false) { + repo.refresh(history) + .onSuccess { _state.update { it.copy(refreshError = null) } } + .onFailure { error -> + Logger.warn("Failed to refresh USDT with '${error.javaClass.simpleName}'", context = TAG) + _state.update { it.copy(refreshError = error.messageResource()) } + } + } + + suspend fun waitForTransfer() { + val state = _state.value + val quote = state.quote ?: return + if (!state.submitted || !state.busy) return + try { + if (quote.destination != UsdtDestination.ARBITRUM) return + repo.waitForTransfer(quote.id) + .onSuccess { _state.update { it.copy(refreshError = null) } } + .onFailure { error -> + Logger.warn("Failed to check USDT payment", error, context = TAG) + _state.update { it.copy(refreshError = error.messageResource()) } + } + } finally { + _state.update { it.copy(busy = false) } + } + } + + fun validateRecipient(value: String, destination: UsdtDestination, onValid: (UsdtPaymentRequest) -> Unit) { + parseUsdtPaymentRequest(value, destination) + .onSuccess { request -> + if (request.chainId != null && destination != UsdtDestination.ARBITRUM) { + _state.update { it.copy(error = UsdtException.WrongNetwork().messageResource()) } + return@onSuccess + } + _state.update { it.copy(error = null) } + onValid(request) + } + .onFailure { error -> _state.update { it.copy(error = error.messageResource()) } } + } + + fun quote(recipient: String, amount: String, destination: UsdtDestination) = viewModelScope.launch { + if (_state.value.busy || _state.value.authenticationRequired || _state.value.warning != null) return@launch + _state.update { UsdtSendState(busy = true, refreshError = it.refreshError) } + repo.quote(recipient, amount, destination) + .onSuccess { quote -> _state.update { it.copy(quote = quote, busy = false) } } + .onFailure { error -> + Logger.warn("Failed to quote USDT with '${error.javaClass.simpleName}'", context = TAG) + _state.update { it.copy(error = error.messageResource(), busy = false) } + } + } + + suspend fun readPaymentSettings(onLoaded: (SettingsData) -> Unit) { + runSuspendCatching { settingsStore.data.first() } + .onSuccess { + _state.update { state -> state.copy(error = null) } + onLoaded(it) + } + .onFailure(::settingsReadFailed) + } + + private fun settingsReadFailed(error: Throwable) { + Logger.warn("Failed to read payment settings", error, context = TAG) + _state.update { it.copy(error = R.string.usdt__error_storage) } + } + + fun confirm() = viewModelScope.launch { + if (_state.value.busy || _state.value.submitted) return@launch + if (_state.value.warning != null || _state.value.authenticationRequired) return@launch + val quote = _state.value.quote ?: return@launch + _state.update { it.copy(busy = true) } + var paymentSettings: SettingsData? = null + try { + readPaymentSettings { paymentSettings = it } + } finally { + _state.update { if (it.quote?.id == quote.id) it.copy(busy = false) else it } + } + val settings = paymentSettings ?: return@launch + if (_state.value.quote?.id != quote.id) return@launch + val warnings = quote.warnings(wallet.value.balance, settings.enableSendAmountWarning) + val warning = warnings.firstOrNull { it !in _state.value.confirmedWarnings } + if (warning != null) { + _state.update { it.copy(warning = warning) } + return@launch + } + if (settings.isPinEnabled && settings.isPinForPaymentsEnabled) { + _state.update { it.copy(authenticationRequired = true) } + } else { + send(quote) + } + } + + fun acceptWarning() { + val warning = _state.value.warning ?: return + _state.update { + it.copy( + warning = null, + confirmedWarnings = (it.confirmedWarnings + warning).toImmutableList() + ) + } + confirm() + } + + fun authenticationVerified() { + if (_state.value.authenticationRequired) { + val quote = _state.value.quote ?: return + _state.update { it.copy(authenticationRequired = false) } + send(quote) + } + } + fun cancelAuthentication() = _state.update { it.copy(authenticationRequired = false) } + fun edit() = _state.update { UsdtSendState(refreshError = it.refreshError) } + + private fun send(quote: UsdtQuote) = viewModelScope.launch { + if (_state.value.quote?.id != quote.id) return@launch + if (_state.value.busy) return@launch + _state.update { it.copy(busy = true, error = null) } + runSuspendCatching { + val payment = sendPayment + if (payment != null) payment(quote) else repo.send(quote).getOrThrow() + } + .onSuccess { + _state.update { it.copy(submitted = true) } + } + .onFailure { error -> + Logger.warn("Failed to send USDT with '${error.javaClass.simpleName}'", context = TAG) + _state.update { + it.copy( + busy = false, + quote = null, + error = error.messageResource() + ) + } + } + } +} + +@Stable +data class UsdtSendState( + val quote: UsdtQuote? = null, + val busy: Boolean = false, + val submitted: Boolean = false, + val authenticationRequired: Boolean = false, + val warning: SanityWarning? = null, + val confirmedWarnings: ImmutableList = persistentListOf(), + @StringRes val error: Int? = null, + @StringRes val refreshError: Int? = null, +) + +private fun UsdtQuote.warnings(balance: ULong?, warnOver100: Boolean): List = buildList { + if (balance != null && amount > balance / 2u) add(SanityWarning.OVER_HALF_BALANCE) + if (warnOver100 && amount > 100_000_000u) add(SanityWarning.VALUE_OVER_100_USD) + if (maximumFee > 10_000_000u) add(SanityWarning.FEE_OVER_10_USD) + if (maximumFee > amount / 2u) add(SanityWarning.FEE_OVER_HALF_VALUE) +} + +@StringRes +@Suppress("CyclomaticComplexMethod") +internal fun Throwable.messageResource(): Int = when (this) { + is UsdtException.NotConfigured -> R.string.usdt__error_configuration + is UsdtException.InvalidAmount -> R.string.usdt__error_amount + is UsdtException.InvalidAddress, is UsdtException.WrongNetwork -> R.string.usdt__error_address + is UsdtException.InsufficientBalance -> R.string.usdt__error_balance + is UsdtException.QuoteExpired -> R.string.usdt__error_expired + is UsdtException.PendingTransfer -> R.string.usdt__error_pending + is UsdtException.DepositNeedsAttention -> R.string.usdt__deposit_attention + is UsdtException.DepositNotFound -> R.string.usdt__deposit_not_found + is UsdtException.DepositAuthorizationRejected -> R.string.usdt__deposit_authorization + is UsdtException.DepositAmountOutOfRange -> R.string.usdt__deposit_amount_out_of_range + is UsdtException.UnsupportedRoute -> R.string.usdt__error_route + is UsdtException.InvalidCredentials -> R.string.usdt__error_wallet + is UsdtException.ClockSkew -> R.string.usdt__error_clock + is UsdtException.UnsupportedDelegation -> R.string.usdt__error_delegation + is UsdtException.BackupUnavailable -> R.string.usdt__error_backup + is UsdtException.InvalidBackup, is UsdtException.Storage -> R.string.usdt__error_storage + is UsdtException.RateLimited -> R.string.usdt__error_rate_limit + is UsdtException.LogRangeTooLarge, is UsdtException.InvalidResponse -> R.string.usdt__error_response + is UsdtException.TransactionRejected -> R.string.usdt__error_rejected + else -> R.string.usdt__error_network +} diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtWalletScreen.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtWalletScreen.kt new file mode 100644 index 0000000000..332703a6d6 --- /dev/null +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtWalletScreen.kt @@ -0,0 +1,425 @@ +package to.bitkit.ui.screens.wallets.usdt + +import androidx.activity.compose.BackHandler +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.IntrinsicSize +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.imePadding +import androidx.compose.foundation.layout.navigationBarsPadding +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.itemsIndexed +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.Icon +import androidx.compose.material3.SheetValue +import androidx.compose.material3.VerticalDivider +import androidx.compose.material3.rememberModalBottomSheetState +import androidx.compose.runtime.Composable +import androidx.compose.runtime.DisposableEffect +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberUpdatedState +import androidx.compose.runtime.saveable.rememberSaveable +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.testTag +import androidx.compose.ui.res.painterResource +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.tooling.preview.Preview +import androidx.compose.ui.unit.dp +import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel +import androidx.lifecycle.Lifecycle +import androidx.lifecycle.compose.LocalLifecycleOwner +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import androidx.lifecycle.repeatOnLifecycle +import com.synonym.bitkitcore.UsdtDestination +import com.synonym.bitkitcore.UsdtTransfer +import com.synonym.bitkitcore.UsdtTransferStatus +import com.synonym.bitkitcore.usdtFormatAmount +import kotlinx.coroutines.delay +import kotlinx.coroutines.launch +import to.bitkit.R +import to.bitkit.models.NewTransactionSheetDetails +import to.bitkit.models.NewTransactionSheetDirection +import to.bitkit.models.NewTransactionSheetType +import to.bitkit.repositories.UsdtWalletState +import to.bitkit.ui.appViewModel +import to.bitkit.ui.components.BiometricsView +import to.bitkit.ui.components.BodyMSB +import to.bitkit.ui.components.BodyS +import to.bitkit.ui.components.BottomSheet +import to.bitkit.ui.components.Caption13Up +import to.bitkit.ui.components.FillWidth +import to.bitkit.ui.components.PrimaryButton +import to.bitkit.ui.components.SecondaryButton +import to.bitkit.ui.components.UsdtAmountHeader +import to.bitkit.ui.components.VerticalSpacer +import to.bitkit.ui.components.WalletBalanceContent +import to.bitkit.ui.scaffold.AppAlertDialog +import to.bitkit.ui.scaffold.AppTopBar +import to.bitkit.ui.scaffold.DrawerNavIcon +import to.bitkit.ui.screens.wallets.activity.components.CircularIcon +import to.bitkit.ui.screens.wallets.activity.components.EmptyActivityRow +import to.bitkit.ui.screens.wallets.activity.components.activityGroupTitleResource +import to.bitkit.ui.screens.wallets.send.SendPinCheckScreen +import to.bitkit.ui.settingsViewModel +import to.bitkit.ui.shared.UiConstants +import to.bitkit.ui.shared.modifiers.clickableAlpha +import to.bitkit.ui.shared.modifiers.sheetHeight +import to.bitkit.ui.shared.util.gradientBackground +import to.bitkit.ui.theme.AppThemeSurface +import to.bitkit.ui.theme.Colors +import to.bitkit.ui.utils.rememberBiometricAuthSupported +import kotlin.time.Duration.Companion.seconds + +@Composable +fun UsdtWalletCard(onClick: () -> Unit, viewModel: UsdtViewModel = hiltViewModel()) { + val wallet by viewModel.wallet.collectAsStateWithLifecycle() + val settings by viewModel.settings.collectAsStateWithLifecycle() + UsdtRefreshEffect(viewModel, pending = wallet.transfers.any { it.status == UsdtTransferStatus.PENDING }) + VerticalSpacer(16.dp) + Row(modifier = Modifier.fillMaxWidth().height(IntrinsicSize.Min)) { + WalletBalanceContent( + title = "USDT", + icon = { + CircularIcon( + icon = painterResource(R.drawable.ic_coins), + iconColor = Colors.Green, + backgroundColor = Colors.Green16, + size = 24.dp, + modifier = Modifier.padding(end = 4.dp) + ) + }, + modifier = Modifier.clickableAlpha(onClick = onClick).padding(vertical = 4.dp) + .padding(end = 8.dp).testTag("UsdtWallet"), + ) { + BodyMSB( + if (settings.hideBalance) { + UiConstants.HIDE_BALANCE_SHORT + } else { + wallet.balance?.let { + usdtFormatAmount(it) + } ?: "—" + } + ) + } + VerticalDivider(color = Colors.Gray4) + FillWidth() + } +} + +@Suppress("CyclomaticComplexMethod") +@OptIn(ExperimentalMaterial3Api::class) +@Composable +fun UsdtWalletScreen(onBack: () -> Unit, viewModel: UsdtViewModel = hiltViewModel()) { + val wallet by viewModel.wallet.collectAsStateWithLifecycle() + val state by viewModel.state.collectAsStateWithLifecycle() + val settings by viewModel.settings.collectAsStateWithLifecycle() + var page by remember { mutableStateOf(UsdtPage.WALLET) } + val sending = page in listOf(UsdtPage.RECIPIENT, UsdtPage.MANUAL, UsdtPage.AMOUNT) + DisposableEffect(viewModel, sending) { + viewModel.isSendPresented = sending + onDispose { viewModel.isSendPresented = false } + } + var selectedTransferId by rememberSaveable { mutableStateOf(null) } + var recipient by remember { mutableStateOf("") } + var amount by remember { mutableStateOf("") } + val destinations by viewModel.destinations.collectAsStateWithLifecycle() + var destination by remember { mutableStateOf(UsdtDestination.ARBITRUM) } + var depositBlocking by remember { mutableStateOf(false) } + val dismissalBlocked = state.busy || state.authenticationRequired || depositBlocking + val dismiss = { + if (!dismissalBlocked) { + viewModel.edit() + page = UsdtPage.WALLET + } + } + val back = { + when { + state.busy -> Unit + state.authenticationRequired -> viewModel.cancelAuthentication() + state.submitted -> dismiss() + state.quote != null -> viewModel.edit() + page in listOf(UsdtPage.AMOUNT, UsdtPage.MANUAL) -> { + viewModel.edit() + page = if (page == UsdtPage.AMOUNT) UsdtPage.MANUAL else UsdtPage.RECIPIENT + } + else -> dismiss() + } + } + BackHandler(enabled = page == UsdtPage.WALLET) { + if (selectedTransferId != null) selectedTransferId = null else onBack() + } + val lifecycle = LocalLifecycleOwner.current.lifecycle + LaunchedEffect(lifecycle, state.submitted) { + if (state.submitted) { + lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) { + viewModel.waitForTransfer() + } + } + } + val submittedStatus = wallet.transfers.firstOrNull { it.id == state.quote?.id }?.status + val paymentSent = state.submitted && !state.busy && submittedStatus == UsdtTransferStatus.CONFIRMED + UsdtRefreshEffect( + viewModel, + pending = wallet.transfers.any { it.status == UsdtTransferStatus.PENDING }, + receiving = page == UsdtPage.RECEIVE, + ) { + if (page == UsdtPage.RECEIVE && !depositBlocking) page = UsdtPage.WALLET + page == UsdtPage.WALLET + } + val selectedTransfer = wallet.transfers.firstOrNull { it.id == selectedTransferId } + if (selectedTransfer != null) { + UsdtActivityDetail(selectedTransfer, settings.hideBalance) { selectedTransferId = null } + } else { + UsdtWalletContent( + wallet = wallet, + error = state.refreshError, + hideBalance = settings.hideBalance, + onReceive = { + viewModel.edit() + page = UsdtPage.RECEIVE + }, + onSend = { + recipient = "" + amount = "" + viewModel.edit() + page = UsdtPage.RECIPIENT + }, + onBack = onBack, + onActivityClick = { selectedTransferId = it.id }, + ) + } + + state.warning?.let { warning -> + AppAlertDialog( + title = stringResource(R.string.common__are_you_sure), + text = stringResource(warning.message), + confirmText = stringResource(R.string.wallet__send_yes), + dismissText = stringResource(R.string.common__cancel), + onConfirm = viewModel::acceptWarning, + onDismiss = viewModel::edit, + modifier = Modifier.testTag(warning.testTag) + ) + } + if (page != UsdtPage.WALLET) { + val blocked by rememberUpdatedState(dismissalBlocked) + val sheetState = rememberModalBottomSheetState( + skipPartiallyExpanded = true, + confirmValueChange = { it != SheetValue.Hidden || !blocked }, + ) + BottomSheet(onDismissRequest = dismiss, sheetState = sheetState) { + BackHandler(onBack = back) + Column( + modifier = Modifier.sheetHeight(isModal = true).gradientBackground() + .navigationBarsPadding().imePadding() + .padding(horizontal = if (paymentSent) 0.dp else 16.dp) + .padding(bottom = 16.dp) + ) { + when { + state.authenticationRequired -> UsdtAuthentication( + useBiometrics = settings.isBiometricEnabled, + onCancel = viewModel::cancelAuthentication, + onVerified = viewModel::authenticationVerified, + ) + page == UsdtPage.RECEIVE -> UsdtDepositReceiveScreen( + viewModel = viewModel, + onBack = back, + onBlockingChange = { depositBlocking = it } + ) + else -> UsdtPaymentContent( + wallet = wallet, state = state, page = page, recipient = recipient, amount = amount, + destination = destination, + destinations = destinations, + onDestinationChange = { + if (destination != it) { + destination = it + recipient = "" + amount = "" + viewModel.edit() + } + }, + onRecipientChange = { + recipient = it + viewModel.edit() + }, + onAmountChange = { amount = it }, + onRecipientContinue = { value -> + viewModel.validateRecipient(value, destination) { request -> + recipient = request.recipient + amount = request.amount?.let { usdtFormatAmount(it) }.orEmpty() + page = UsdtPage.AMOUNT + } + }, + onPageChange = { + if (!state.busy) { + viewModel.edit() + page = it + } + }, + onBack = back, onReview = { viewModel.quote(recipient, amount, destination) }, + onConfirm = { viewModel.confirm() }, onDone = dismiss, + hideBalance = settings.hideBalance, + onDetails = { + selectedTransferId = state.quote?.id + dismiss() + }, + ) + } + } + } + } +} + +@Composable +private fun UsdtWalletContent( + wallet: UsdtWalletState, + error: Int?, + hideBalance: Boolean, + onReceive: () -> Unit, + onSend: () -> Unit, + onBack: () -> Unit, + onActivityClick: (UsdtTransfer) -> Unit = {}, +) { + val settings = settingsViewModel + val allowSwipe by settings?.enableSwipeToHideBalance?.collectAsStateWithLifecycle() ?: remember { + mutableStateOf(false) + } + Column(modifier = Modifier.fillMaxSize()) { + AppTopBar(titleText = "USDT", onBackClick = onBack, actions = { DrawerNavIcon() }) + LazyColumn(modifier = Modifier.padding(horizontal = 16.dp)) { + item { + VerticalSpacer(16.dp) + UsdtAmountHeader( + amount = wallet.balance?.let { usdtFormatAmount(it) } ?: "—", + network = "Arbitrum One", + hideBalance = hideBalance, + onToggleHide = if (allowSwipe) ({ settings?.setHideBalance(!hideBalance) }) else null, + modifier = Modifier.testTag("UsdtBalance") + ) + VerticalSpacer(32.dp) + Row(horizontalArrangement = Arrangement.spacedBy(16.dp)) { + SecondaryButton( + text = stringResource(R.string.usdt__receive), + onClick = onReceive, + icon = { Icon(painterResource(R.drawable.ic_received), null, tint = Colors.Green) }, + modifier = Modifier.weight(1f).testTag("UsdtReceive") + ) + PrimaryButton( + text = stringResource(R.string.usdt__send), + onClick = onSend, + icon = { Icon(painterResource(R.drawable.ic_sent), null, tint = Colors.Green) }, + modifier = Modifier.weight(1f).testTag("UsdtSend") + ) + } + VerticalSpacer(32.dp) + error?.let { + BodyS(stringResource(it), color = Colors.Brand) + VerticalSpacer(16.dp) + } + if (wallet.transfers.isEmpty()) { + Caption13Up(stringResource(R.string.usdt__activity), color = Colors.White64) + VerticalSpacer(16.dp) + EmptyActivityRow(onClick = onReceive) + } + } + itemsIndexed(wallet.transfers, key = { _, transfer -> transfer.id }) { index, transfer -> + val heading = activityGroupTitleResource(transfer.timestamp) + if (index == 0 || activityGroupTitleResource(wallet.transfers[index - 1].timestamp) != heading) { + Caption13Up( + stringResource(heading), + color = Colors.White64, + modifier = Modifier.padding(vertical = 8.dp) + ) + } + UsdtActivityRow(transfer, hideBalance, onClick = { onActivityClick(transfer) }) + VerticalSpacer(16.dp) + } + item { + if (!wallet.historyComplete) BodyS(stringResource(R.string.usdt__history_sync), color = Colors.White64) + VerticalSpacer(120.dp) + } + } + } +} + +internal val UsdtDestination.label: String get() = when (this) { + UsdtDestination.STABLE -> "Stable" + UsdtDestination.ETHEREUM -> "Ethereum" + UsdtDestination.ARBITRUM -> "Arbitrum One" + UsdtDestination.POLYGON -> "Polygon" + UsdtDestination.PLASMA -> "Plasma" + UsdtDestination.BASE -> "Base" + UsdtDestination.BSC -> "BNB Smart Chain" + UsdtDestination.SOLANA -> "Solana" + UsdtDestination.TRON -> "Tron" +} + +@Composable +private fun UsdtRefreshEffect( + viewModel: UsdtViewModel, + pending: Boolean = false, + receiving: Boolean = false, + onReceived: () -> Boolean = { true }, +) { + val lifecycle = LocalLifecycleOwner.current.lifecycle + val app = appViewModel + val handleReceived by rememberUpdatedState(onReceived) + val isPending by rememberUpdatedState(pending) + val isReceiving by rememberUpdatedState(receiving) + LaunchedEffect(lifecycle, viewModel, app) { + lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) { + launch { + viewModel.receivedTxs.collect { transfer -> + if (handleReceived()) { + app?.showTransactionSheet( + NewTransactionSheetDetails( + type = NewTransactionSheetType.ONCHAIN, + direction = NewTransactionSheetDirection.RECEIVED, + usdtAmount = transfer.amount, + ) + ) + } + } + } + while (true) { + viewModel.refresh(history = true) + delay(if (isReceiving || isPending) 10.seconds else 30.seconds) + } + } + } +} + +@Composable +internal fun UsdtAuthentication(useBiometrics: Boolean, onCancel: () -> Unit, onVerified: () -> Unit) { + val supported = rememberBiometricAuthSupported() + var fallbackToPin by remember { mutableStateOf(false) } + if (useBiometrics && supported && !fallbackToPin) { + BiometricsView(onSuccess = onVerified, onFailure = { fallbackToPin = true }) + } else { + SendPinCheckScreen(onBack = onCancel, onSuccess = onVerified) + } +} + +internal enum class UsdtPage { + WALLET, + RECEIVE, + RECIPIENT, + MANUAL, + AMOUNT, +} + +@Preview +@Composable +private fun Preview() { + AppThemeSurface { + UsdtWalletContent(UsdtWalletState(balance = 100_000_000u), null, false, {}, {}, {}) + } +} diff --git a/app/src/main/java/to/bitkit/ui/sheets/NewTransactionSheet.kt b/app/src/main/java/to/bitkit/ui/sheets/NewTransactionSheet.kt index 7219da0ab5..9c00d00b63 100644 --- a/app/src/main/java/to/bitkit/ui/sheets/NewTransactionSheet.kt +++ b/app/src/main/java/to/bitkit/ui/sheets/NewTransactionSheet.kt @@ -18,6 +18,7 @@ import androidx.compose.runtime.CompositionLocalProvider import androidx.compose.runtime.getValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.toArgb import androidx.compose.ui.layout.ContentScale import androidx.compose.ui.platform.testTag import androidx.compose.ui.res.painterResource @@ -25,9 +26,13 @@ import androidx.compose.ui.res.stringResource import androidx.compose.ui.tooling.preview.Preview import androidx.compose.ui.unit.dp import androidx.lifecycle.compose.collectAsStateWithLifecycle +import com.airbnb.lottie.LottieProperty import com.airbnb.lottie.compose.LottieAnimation import com.airbnb.lottie.compose.LottieCompositionSpec import com.airbnb.lottie.compose.rememberLottieComposition +import com.airbnb.lottie.compose.rememberLottieDynamicProperties +import com.airbnb.lottie.compose.rememberLottieDynamicProperty +import com.synonym.bitkitcore.usdtFormatAmount import to.bitkit.R import to.bitkit.models.NewTransactionSheetDetails import to.bitkit.models.NewTransactionSheetDirection @@ -40,10 +45,12 @@ import to.bitkit.ui.components.BottomSheetPreview import to.bitkit.ui.components.PrimaryButton import to.bitkit.ui.components.SHEET_INTRO_IMAGE_WIDTH_FRACTION import to.bitkit.ui.components.SecondaryButton +import to.bitkit.ui.components.UsdtAmountHeader import to.bitkit.ui.scaffold.SheetTopBar import to.bitkit.ui.shared.modifiers.sheetHeight import to.bitkit.ui.shared.util.gradientBackground import to.bitkit.ui.theme.AppThemeSurface +import to.bitkit.ui.theme.Colors import to.bitkit.ui.utils.localizedRandom import to.bitkit.viewmodels.AppViewModel @@ -52,6 +59,7 @@ import to.bitkit.viewmodels.AppViewModel fun NewTransactionSheet( appViewModel: AppViewModel, bottomSheetOverlayState: BottomSheetOverlayState, + hideBalance: Boolean, modifier: Modifier = Modifier, ) { val details by appViewModel.transactionSheet.collectAsStateWithLifecycle() @@ -62,6 +70,7 @@ fun NewTransactionSheet( ) { NewTransactionSheetView( details = details, + hideBalance = hideBalance, onCloseClick = { appViewModel.hideNewTransactionSheet() }, onDetailClick = { appViewModel.onClickActivityDetail() @@ -82,6 +91,8 @@ fun NewTransactionSheetView( onCloseClick: () -> Unit, onDetailClick: () -> Unit, modifier: Modifier = Modifier, + usdtNetwork: String = "Arbitrum One", + hideBalance: Boolean = false, ) { Box(modifier = modifier) { val composition by rememberLottieComposition( @@ -93,6 +104,17 @@ fun NewTransactionSheetView( ) LottieAnimation( composition = composition, + dynamicProperties = if (details.usdtAmount != null) { + rememberLottieDynamicProperties( + rememberLottieDynamicProperty( + property = LottieProperty.COLOR, + value = Colors.Green.toArgb(), + keyPath = arrayOf("**"), + ) + ) + } else { + null + }, contentScale = ContentScale.Crop, iterations = 100, modifier = Modifier @@ -132,28 +154,36 @@ fun NewTransactionSheetView( .testTag("transaction_content_column") .padding(horizontal = 16.dp), ) { - val titleText = when (details.type) { - NewTransactionSheetType.LIGHTNING -> when (details.direction) { - NewTransactionSheetDirection.SENT -> stringResource(R.string.wallet__send_sent) - else -> stringResource(R.string.wallet__instant_payment_received) + val titleText = stringResource( + when { + details.usdtAmount != null -> if (details.direction == NewTransactionSheetDirection.SENT) { + R.string.usdt__payment_sent + } else { + R.string.usdt__payment_received + } + details.direction == NewTransactionSheetDirection.SENT -> R.string.wallet__send_sent + details.type == NewTransactionSheetType.LIGHTNING -> R.string.wallet__instant_payment_received + else -> R.string.wallet__payment_received } - - NewTransactionSheetType.ONCHAIN -> when (details.direction) { - NewTransactionSheetDirection.SENT -> stringResource(R.string.wallet__send_sent) - else -> stringResource(R.string.wallet__payment_received) - } - } + ) SheetTopBar(titleText) Spacer(modifier = Modifier.height(24.dp)) - BalanceHeaderView( - sats = details.sats, - modifier = Modifier - .fillMaxWidth() - .testTag("ReceivedTransaction") - ) + if (details.usdtAmount != null) { + UsdtAmountHeader( + amount = usdtFormatAmount(details.usdtAmount), + network = usdtNetwork, + hideBalance = hideBalance, + modifier = Modifier.testTag("ReceivedTransaction") + ) + } else { + BalanceHeaderView( + sats = details.sats, + modifier = Modifier.fillMaxWidth().testTag("ReceivedTransaction") + ) + } Spacer(modifier = Modifier.weight(1f)) diff --git a/app/src/main/java/to/bitkit/ui/sheets/SendSheet.kt b/app/src/main/java/to/bitkit/ui/sheets/SendSheet.kt index 64ec4d2c62..2634e0344b 100644 --- a/app/src/main/java/to/bitkit/ui/sheets/SendSheet.kt +++ b/app/src/main/java/to/bitkit/ui/sheets/SendSheet.kt @@ -80,6 +80,7 @@ import to.bitkit.ui.screens.wallets.send.SendPendingViewModel import to.bitkit.ui.screens.wallets.send.SendPinCheckScreen import to.bitkit.ui.screens.wallets.send.SendQuickPayScreen import to.bitkit.ui.screens.wallets.send.SendRecipientScreen +import to.bitkit.ui.screens.wallets.usdt.PaykitUsdtReview import to.bitkit.ui.screens.wallets.withdraw.WithdrawConfirmScreen import to.bitkit.ui.screens.wallets.withdraw.WithdrawErrorScreen import to.bitkit.ui.settings.support.SupportScreen @@ -126,7 +127,7 @@ fun SendSheet( var routingCacheResetAttempted by rememberSaveable(startDestination) { mutableStateOf(false) } val shouldShowSyncOverlay = run { - if (preparingRequest != null) return@run false + if (preparingRequest != null || sendUiState.paykitUsesUsdt) return@run false if (sendUiState.hardwareWalletId != null) return@run false if (!lightningState.nodeLifecycleState.isRunning()) return@run true val hasAnyChannels = lightningState.channels.isNotEmpty() @@ -236,6 +237,7 @@ fun SendSheet( is SendEffect.NavigateToScan -> navController.navigateTo(SendRoute.QrScanner) is SendEffect.NavigateToCoinSelection -> navController.navigateToCoinSelection() is SendEffect.NavigateToConfirm -> navController.navigateTo(SendRoute.Confirm) + is SendEffect.NavigateToUsdtReview -> navController.navigateTo(SendRoute.UsdtReview) is SendEffect.NavigateToHardwareSign -> navController.navigateTo(SendRoute.HardwareSign) is SendEffect.PopBack -> navController.popBackStack(it.route, inclusive = false) is SendEffect.PaymentSuccess -> { @@ -298,11 +300,25 @@ fun SendSheet( appViewModel.clearActiveContactPaymentContext() navController.popBackStack() }, - onOpenPayment = { paymentRequest, publicKey, privatePaymentContext -> - appViewModel.openContactPayment(paymentRequest, publicKey, privatePaymentContext) + onOpenPayment = { paymentRequest, publicKey, privatePaymentContext, endpoints -> + appViewModel.openContactPayment( + paymentRequest, + publicKey, + privatePaymentContext, + endpoints = endpoints + ) }, ) } + composableWithDefaultTransitions { + val uiState by appViewModel.sendUiState.collectAsStateWithLifecycle() + PaykitUsdtReview( + uiState = uiState, + app = appViewModel, + onBack = { navController.popBackStack() }, + onDone = { appViewModel.hideSheet() } + ) + } composableWithDefaultTransitions { val uiState by appViewModel.sendUiState.collectAsStateWithLifecycle() val lightningState by walletViewModel.lightningState.collectAsStateWithLifecycle() @@ -782,6 +798,9 @@ sealed interface SendRoute { @Serializable data object Amount : DeepLinkStart + @Serializable + data object UsdtReview : InternalOnly + @Serializable data object QrScanner : DeepLinkStart diff --git a/app/src/main/java/to/bitkit/ui/utils/NumberPadInputHandler.kt b/app/src/main/java/to/bitkit/ui/utils/NumberPadInputHandler.kt new file mode 100644 index 0000000000..fcdb1b87f8 --- /dev/null +++ b/app/src/main/java/to/bitkit/ui/utils/NumberPadInputHandler.kt @@ -0,0 +1,57 @@ +package to.bitkit.ui.utils + +import to.bitkit.ui.components.KEY_DECIMAL +import to.bitkit.ui.components.KEY_DELETE + +object NumberPadInputHandler { + fun handleInput( + key: String, + current: String, + maxLength: Int, + maxDecimals: Int, + ): String { + return if (maxDecimals == 0) { + handleIntegerInput(key, current, maxLength) + } else { + handleDecimalInput(key, current, maxLength, maxDecimals) + } + } + + private fun handleIntegerInput(key: String, current: String, maxLength: Int): String { + if (key == KEY_DELETE) return current.dropLast(1) + + if (current == "0") return key + if (current.length >= maxLength) return current + + return current + key + } + + @Suppress("ReturnCount") + private fun handleDecimalInput( + key: String, + current: String, + maxLength: Int, + maxDecimals: Int, + ): String { + val parts = current.split(".", limit = 2) + val decimalPart = if (parts.size > 1) parts[1] else "" + + if (key == KEY_DELETE) { + if (current == "0.") return "" + return current.dropLast(1) + } + + if (current == "0" && key != ".") return key + + if (current.length >= maxLength) return current + + if (decimalPart.length >= maxDecimals) return current + + if (key == KEY_DECIMAL) { + if (current.contains(".")) return current + if (current.isEmpty()) return "0." + } + + return current + key + } +} diff --git a/app/src/main/java/to/bitkit/ui/utils/PubkyAuthErrorMessage.kt b/app/src/main/java/to/bitkit/ui/utils/PubkyAuthErrorMessage.kt index b254013094..252c03ba5e 100644 --- a/app/src/main/java/to/bitkit/ui/utils/PubkyAuthErrorMessage.kt +++ b/app/src/main/java/to/bitkit/ui/utils/PubkyAuthErrorMessage.kt @@ -21,6 +21,7 @@ fun Throwable.localizedPubkyAuthMessage(context: Context): String? { private fun Throwable.pubkyAuthMessageResource() = when (this) { is PubkyRingAuthTimeoutError -> R.string.profile__auth_error_timeout is PubkyAuthRequestError.InvalidUrl -> R.string.profile__auth_error_invalid_url + PubkyAuthRequestError.InvalidPaymentDetails -> R.string.profile__auth_approval_usdt_unavailable PubkyAuthRequestError.RequesterChanged -> R.string.profile__auth_error_invalid_url PubkyAuthRequestError.MissingBitkitClaim -> R.string.profile__auth_error_missing_claim PubkyAuthRequestError.DuplicateBitkitClaim -> R.string.profile__auth_error_duplicate_claim diff --git a/app/src/main/java/to/bitkit/usecases/WipeWalletUseCase.kt b/app/src/main/java/to/bitkit/usecases/WipeWalletUseCase.kt index 950ac0e986..6b9519d9b3 100644 --- a/app/src/main/java/to/bitkit/usecases/WipeWalletUseCase.kt +++ b/app/src/main/java/to/bitkit/usecases/WipeWalletUseCase.kt @@ -47,6 +47,7 @@ class WipeWalletUseCase @Inject constructor( private val firebaseMessaging: FirebaseMessaging, private val migrationService: MigrationService, private val paykitSdkService: PaykitSdkService, + private val usdtRepo: to.bitkit.repositories.UsdtRepo, ) { private val wipeMutex = Mutex() @@ -97,7 +98,7 @@ class WipeWalletUseCase @Inject constructor( step("clear migration data") { migrationService.cleanupAfterMigration() } step("clear Paykit address reservations") { privatePaykitAddressReservationRepo.clear() } step("wipe Pubky local state") { pubkyRepo.wipeLocalState() } - val keychainWiped = step("wipe keychain") { keychain.wipe() } + val keychainWiped = step("wipe USDT and keychain") { usdtRepo.wipe { keychain.wipe() } } step("delete FCM token") { firebaseMessaging.deleteToken() } step("wipe core data") { coreService.wipeData() } step("clear database") { db.clearAllTables() } diff --git a/app/src/main/java/to/bitkit/viewmodels/AmountInputViewModel.kt b/app/src/main/java/to/bitkit/viewmodels/AmountInputViewModel.kt index 124ed07631..ec96360b6a 100644 --- a/app/src/main/java/to/bitkit/viewmodels/AmountInputViewModel.kt +++ b/app/src/main/java/to/bitkit/viewmodels/AmountInputViewModel.kt @@ -25,9 +25,9 @@ import to.bitkit.models.formatToModernDisplay import to.bitkit.repositories.AmountInputHandler import to.bitkit.repositories.CurrencyState import to.bitkit.ui.LocalCurrencies -import to.bitkit.ui.components.KEY_DECIMAL import to.bitkit.ui.components.KEY_DELETE import to.bitkit.ui.components.NumberPadType +import to.bitkit.ui.utils.NumberPadInputHandler import java.math.BigDecimal import java.text.NumberFormat import java.util.Locale @@ -74,7 +74,7 @@ class AmountInputViewModel @Inject constructor( val maxLength = getMaxLength(currencyState) val maxDecimals = getMaxDecimals(currencyState) - val newText = handleInput(key = key, current = rawInputText, maxLength, maxDecimals) + val newText = NumberPadInputHandler.handleInput(key = key, current = rawInputText, maxLength, maxDecimals) if (newText == rawInputText && key != KEY_DELETE) { triggerErrorState(key) @@ -369,62 +369,6 @@ class AmountInputViewModel @Inject constructor( .toDoubleOrNull() ?.let { fiat -> amountInputHandler.convertFiatToSats(fiat) } } - - private fun handleInput( - key: String, - current: String, - maxLength: Int, - maxDecimals: Int, - ): String { - return if (maxDecimals == 0) { - handleIntegerInput(key, current, maxLength) - } else { - handleDecimalInput(key, current, maxLength, maxDecimals) - } - } - - private fun handleIntegerInput(key: String, current: String, maxLength: Int): String { - if (key == KEY_DELETE) return current.dropLast(1) - - if (current == "0") return key - if (current.length >= maxLength) return current - - return current + key - } - - @Suppress("ReturnCount") - private fun handleDecimalInput( - key: String, - current: String, - maxLength: Int, - maxDecimals: Int, - ): String { - val parts = current.split(".", limit = 2) - val decimalPart = if (parts.size > 1) parts[1] else "" - - if (key == KEY_DELETE) { - if (current == "0.") return "" - return current.dropLast(1) - } - - // Handle leading zeros - replace "0" with new digit but allow "0." - if (current == "0" && key != ".") return key - - // Limit to maxLength - if (current.length >= maxLength) return current - - // Limit decimal places - if (decimalPart.length >= maxDecimals) return current - - if (key == KEY_DECIMAL) { - // No multiple decimal symbols - if (current.contains(".")) return current - // Add leading zero - if (current.isEmpty()) return "0." - } - - return current + key - } } data class AmountInputUiState( diff --git a/app/src/main/java/to/bitkit/viewmodels/AppViewModel.kt b/app/src/main/java/to/bitkit/viewmodels/AppViewModel.kt index 9803c2bb31..0383031c1c 100644 --- a/app/src/main/java/to/bitkit/viewmodels/AppViewModel.kt +++ b/app/src/main/java/to/bitkit/viewmodels/AppViewModel.kt @@ -1,3 +1,5 @@ +@file:OptIn(kotlin.time.ExperimentalTime::class) + package to.bitkit.viewmodels import android.content.Context @@ -26,6 +28,7 @@ import com.synonym.bitkitcore.OnChainInvoice import com.synonym.bitkitcore.PaymentType import com.synonym.bitkitcore.Scanner import com.synonym.bitkitcore.SortDirection +import com.synonym.bitkitcore.UsdtQuote import com.synonym.paykit.PaymentRequestLifecycleState import dagger.hilt.android.lifecycle.HiltViewModel import dagger.hilt.android.qualifiers.ApplicationContext @@ -106,6 +109,7 @@ import to.bitkit.ext.maxSendableSat import to.bitkit.ext.maxWithdrawableSat import to.bitkit.ext.minSendableSat import to.bitkit.ext.minWithdrawableSat +import to.bitkit.ext.nowMillis import to.bitkit.ext.rawId import to.bitkit.ext.removeSpaces import to.bitkit.ext.runSuspendCatching @@ -124,6 +128,10 @@ import to.bitkit.models.NewTransactionSheetDetails import to.bitkit.models.NewTransactionSheetDirection import to.bitkit.models.NewTransactionSheetType import to.bitkit.models.NodeLifecycleState +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAmountError +import to.bitkit.models.PaykitAsset +import to.bitkit.models.PaykitRequestPayment import to.bitkit.models.PubkyAuthRequest import to.bitkit.models.PubkyContactLink import to.bitkit.models.PubkyProfile @@ -152,6 +160,7 @@ import to.bitkit.repositories.ConnectivityRepo import to.bitkit.repositories.ConnectivityState import to.bitkit.repositories.ContactPaymentSettingsRepo import to.bitkit.repositories.CurrencyRepo +import to.bitkit.repositories.Endpoint import to.bitkit.repositories.HealthRepo import to.bitkit.repositories.HwWalletRepo import to.bitkit.repositories.IncomingPaykitPaymentRequestFailureReason @@ -181,6 +190,7 @@ import to.bitkit.repositories.PaykitPaymentRequestTarget import to.bitkit.repositories.PaykitSubscription import to.bitkit.repositories.PaykitSubscriptionDraft import to.bitkit.repositories.PaykitSubscriptionId +import to.bitkit.repositories.PaykitUsdtPaymentRepo import to.bitkit.repositories.PaymentPendingException import to.bitkit.repositories.PendingPaymentNotification import to.bitkit.repositories.PendingPaymentRepo @@ -196,9 +206,11 @@ import to.bitkit.repositories.QuickPayPaymentFailedError import to.bitkit.repositories.QuickPayRepo import to.bitkit.repositories.SamRockRepo import to.bitkit.repositories.TransferRepo +import to.bitkit.repositories.UsdtRepo import to.bitkit.repositories.WalletRepo import to.bitkit.repositories.WidgetsRepo import to.bitkit.repositories.incomingPaymentRequestFailureReason +import to.bitkit.repositories.paykitRate import to.bitkit.services.AppUpdaterService import to.bitkit.services.CoreService import to.bitkit.services.MigrationService @@ -232,6 +244,7 @@ import java.math.BigDecimal import java.util.concurrent.atomic.AtomicLong import javax.inject.Inject import kotlin.coroutines.cancellation.CancellationException +import kotlin.time.Clock import kotlin.time.Duration import kotlin.time.Duration.Companion.hours import kotlin.time.Duration.Companion.milliseconds @@ -279,6 +292,8 @@ class AppViewModel @Inject constructor( private val paykitPaymentProofRepo: PaykitPaymentProofRepo, private val paykitPaymentRequestDiagnostics: PaykitPaymentRequestDiagnostics, private val refreshContactPaykitLink: RefreshContactPaykitLinkUseCase, + private val usdtRepo: UsdtRepo, + val paykitUsdtPayments: PaykitUsdtPaymentRepo, private val samRockRepo: SamRockRepo, private val appUpdateSheet: AppUpdateTimedSheet, private val backupSheet: BackupTimedSheet, @@ -406,6 +421,18 @@ class AppViewModel @Inject constructor( private val processedPayments = mutableSetOf() private val contactPaymentContextLock = Any() private var activeContactPaymentContext: ContactPaymentContext? = null + val usdtWallet = usdtRepo.state + var isPaykitUsdtBusy by mutableStateOf(false) + private set + + fun updatePaykitUsdtBusy(busy: Boolean) { isPaykitUsdtBusy = busy } + + val paykitReceivingMethods = combine(settingsStore.data, lightningRepo.lightningState) { settings, _ -> + paykitPaymentRequestRepo.acceptedPaymentEndpointIdentifiers(settings) + }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyList()) + + private var paykitPaymentTerms: PaykitRequestPayment? = null + private var paykitReviewedAmount: PaykitAmount? = null private val pendingContactPaymentContexts = mutableMapOf() private val _requestedPaymentRequestId = MutableStateFlow(null) val requestedPaymentRequestId = _requestedPaymentRequestId.asStateFlow() @@ -988,6 +1015,7 @@ class AppViewModel @Inject constructor( return result.onSuccess { activityRepo.backfillPaykitContacts() clearHandledSubscriptionNotification() + if (mode == PaykitPaymentRequestRefreshMode.FULL) reconcilePaykitUsdt() presentNextIncomingPaykitPaymentRequest() } } @@ -1151,25 +1179,23 @@ class AppViewModel @Inject constructor( } } viewModelScope.launch { - paykitPaymentRequestRepo.pendingRequests.drop(1).collect { requests -> - retainPaymentRequestPresentationState(requests) - val activeRequest = activeIncomingPaymentRequest() - if ( - activeRequest != null && - !isSubmittingPaymentRequest && - uncertainOnchainPaymentRequestId != activeRequest.id - ) { - if (currentSheet.value is Sheet.Send && requests.none { it.id == activeRequest.id }) { - hideSheet() - } - } - if ( - isPaykitEnabled.value && paymentRequestIdentity != null && - PubkyPublicKeyFormat.matches(paymentRequestIdentity, pubkyRepo.publicKey.value) - ) { - presentNextIncomingPaykitPaymentRequest() - } - } + paykitPaymentRequestRepo.pendingRequests.drop(1).collect(::onPendingPaykitRequestsChanged) + } + } + + private suspend fun onPendingPaykitRequestsChanged(requests: List) { + retainPaymentRequestPresentationState(requests) + val activeRequest = activeIncomingPaymentRequest() + val isProtected = isSubmittingPaymentRequest || uncertainOnchainPaymentRequestId == activeRequest?.id || + isPreparedContactPayment(synchronized(contactPaymentContextLock) { activeContactPaymentContext }) + if (activeRequest != null && !isProtected) { + if (currentSheet.value is Sheet.Send && requests.none { it.id == activeRequest.id }) hideSheet() + } + if ( + isPaykitEnabled.value && paymentRequestIdentity != null && + PubkyPublicKeyFormat.matches(paymentRequestIdentity, pubkyRepo.publicKey.value) + ) { + presentNextIncomingPaykitPaymentRequest() } } @@ -1463,6 +1489,7 @@ class AppViewModel @Inject constructor( incomingPaymentRequest = request, selectedTags = requestedPaymentRequestTags.takeIf { requestedPaymentRequestId.value == request.id } ?: persistentListOf(), + endpoints = result.endpoints, ) return true } @@ -3062,7 +3089,150 @@ class AppViewModel @Inject constructor( launchScan(source = ScanSource.ADDRESS_CONTINUE, data = data, routePubkyKeys = true) } + fun onUsdtAmountChange(value: String) { + if (activeIncomingPaymentRequest() != null) return + _sendUiState.update { it.copy(paykitAmount = value, isAmountInputValid = validUsdtAmount(value)) } + } + + suspend fun refreshPaykitRequestAmount() { + val original = activeIncomingPaymentRequest() ?: return + val request = paykitPaymentRequestRepo.pendingRequests.value.firstOrNull { it.id == original.id } ?: original + if (request != original) { + synchronized(contactPaymentContextLock) { + activeContactPaymentContext?.takeIf { it.incomingPaymentRequest?.id == original.id }?.let { + activeContactPaymentContext = it.copy(incomingPaymentRequest = request) + } + } + } + val target = if (_sendUiState.value.paykitUsesUsdt) PaykitAsset.USDT else PaykitAsset.BTC + val converted = runCatching { + request.payment(target, Clock.System.now()).takeIf { it.isValid(Clock.System.now()) }?.amount + }.getOrNull() + _sendUiState.update { state -> + val sats = if (target == PaykitAsset.BTC) converted?.atomic ?: 0u else state.amount + val tokenAmount = if (target == PaykitAsset.USDT) converted?.value.orEmpty() else state.paykitAmount + state.copy( + paykitRateUnavailable = converted == null, + amount = sats, + paykitAmount = tokenAmount, + isAmountInputValid = converted != null && if (state.paykitUsesUsdt) { + validUsdtAmount(tokenAmount) + } else { + validateAmount(sats) + } + ) + } + } + + private fun validUsdtAmount(value: String): Boolean = runCatching { + PaykitAmount.parse(PaykitAsset.USDT, value).atomic <= (usdtRepo.state.value.balance ?: 0u) + }.getOrDefault(false) + + suspend fun sendPaykitUsdt(quote: UsdtQuote) { + val current = synchronized(contactPaymentContextLock) { activeContactPaymentContext } + ?.takeUnless { isSubmittingPaymentRequest } ?: throw PaykitPaymentRequestError.RequestUnavailable + isSubmittingPaymentRequest = current.incomingPaymentRequest != null + val reviewedAmount = paykitReviewedAmount + val paymentTerms = paykitPaymentTerms + try { + paykitUsdtPayments.prepare(current, quote, reviewedAmount, paymentTerms).getOrThrow() + if (synchronized(contactPaymentContextLock) { activeContactPaymentContext } != current || + !prepareContactPayment(current) || + synchronized(contactPaymentContextLock) { activeContactPaymentContext } != current + ) { + throw PaykitPaymentRequestError.RequestUnavailable + } + paykitUsdtPayments.send( + quote + ) { authorizeUsdtExecution(current, reviewedAmount, paymentTerms) }.getOrThrow() + } finally { + isSubmittingPaymentRequest = false + } + } + + private suspend fun authorizeUsdtExecution( + current: ContactPaymentContext, + reviewedAmount: PaykitAmount?, + paymentTerms: PaykitRequestPayment?, + ) { + current.incomingPaymentRequest?.let { paykitPaymentRequestRepo.ensurePaymentAllowed(it).getOrThrow() } + if (synchronized(contactPaymentContextLock) { activeContactPaymentContext } != current || + paykitReviewedAmount != reviewedAmount || paykitPaymentTerms != paymentTerms + ) { + throw PaykitPaymentRequestError.RequestUnavailable + } + current.incomingPaymentRequest?.let { request -> + val now = Clock.System.now() + val terms = request.payment(PaykitAsset.USDT, now, paymentTerms?.quoteId) + if (terms != paymentTerms || !terms.isValid(now) || terms.amount != reviewedAmount) { + throw PaykitPaymentRequestError.RequestUnavailable + } + } + } + + suspend fun reconcilePaykitUsdt() { + if (!Env.isUsdtEnabled) return + val previousReceipts = paykitUsdtPayments.receipts.value + paykitUsdtPayments.reconcile().onSuccess { + if (previousReceipts != paykitUsdtPayments.receipts.value) { + paykitPaymentRequestRepo.refreshAfterStateChange(PaykitPaymentRequestRefreshMode.STORED) + } + }.onFailure { + Logger.warn("Failed to reconcile Paykit USDT payments", it, context = TAG) + } + } + + private suspend fun openPaykitEndpoints(payment: ContactPaymentContext, fromMainScanner: Boolean) { + val decoded = payment.endpoints.filter { it.methodId != MethodId.UsdtArbitrum } + .map { coreService.decode(it.paymentRequest) } + val address = decoded.filterIsInstance().lastOrNull()?.invoice?.address.orEmpty() + val invoice = decoded.filterIsInstance().lastOrNull()?.invoice + val lnurl = decoded.filterIsInstance().lastOrNull()?.let { LnurlParams.LnurlPay(it.data) } + val recipient = payment.endpoints.firstOrNull { it.methodId == MethodId.UsdtArbitrum }?.value + val hasBitcoinEndpoint = address.isNotEmpty() || invoice != null || lnurl != null + val useUsdt = recipient != null && prefersUsdt(payment, hasBitcoinEndpoint) + val target = if (useUsdt) PaykitAsset.USDT else PaykitAsset.BTC + val amount = requestAmount(payment, target) + _sendUiState.update { + it.copy( + address = address, addressInput = address, isAddressInputValid = address.isNotEmpty(), + decodedInvoice = invoice, lnurl = lnurl, paykitUsesUsdt = useUsdt, usdtRecipient = recipient, + amount = if (target == PaykitAsset.BTC) amount?.atomic ?: 0u else 0u, + paykitAmount = if (target == PaykitAsset.USDT) amount?.value.orEmpty() else "", + payMethod = if (invoice != null || lnurl != null) SendMethod.LIGHTNING else SendMethod.ONCHAIN + ) + } + usdtRepo.refresh(history = false) + _sendUiState.update { + it.copy( + isAmountInputValid = if (it.paykitUsesUsdt) { + validUsdtAmount( + it.paykitAmount + ) + } else { + validateAmount(it.amount) + } + ) + } + refreshPaykitRequestAmount() + updateCanSwitchWallet() + navigateToSendRoute(fromMainScanner, SendRoute.Amount, SendEffect.NavigateToAmount) + } + + private fun requestAmount(payment: ContactPaymentContext, target: PaykitAsset): PaykitAmount? = + payment.incomingPaymentRequest?.let { + runCatching { it.payment(target, Clock.System.now()).amount }.getOrNull() + } + + private fun prefersUsdt(payment: ContactPaymentContext, hasBitcoinEndpoint: Boolean): Boolean { + val request = payment.incomingPaymentRequest + val requiresUsdt = request != null && + (request.amount.asset != PaykitAsset.BTC || paykitUsdtPayments.hasBinding(request.id)) + return requiresUsdt || !hasBitcoinEndpoint || walletRepo.balanceState.value.maxSendOnchainSats == 0uL + } + private suspend fun onAmountChange(amount: ULong) { + if (_sendUiState.value.paykitUsesUsdt) return _sendUiState.update { it.copy( amount = amount, @@ -3160,10 +3330,60 @@ class AppViewModel @Inject constructor( val selected = current.selectedFundingSource() val selectedIndex = sources.indexOf(selected).takeIf { it >= 0 } ?: 0 val nextSource = sources[(selectedIndex + 1) % sources.size] + val target = if (nextSource == SendFundingSource.Usdt) PaykitAsset.USDT else PaykitAsset.BTC + val converted = try { + paymentAmountForSource(current, target) + } catch (_: PaykitAmountError.RateUnavailable) { + _sendUiState.update { it.copy(paykitRateUnavailable = true) } + return + } catch (_: PaykitAmountError) { + _sendUiState.update { it.copy(paykitRateUnavailable = false) } + return + } + _sendUiState.update { + it.copy( + isFundingSourceLoading = nextSource is SendFundingSource.Hardware, + paykitUsesUsdt = target == PaykitAsset.USDT, + paykitRateUnavailable = false, + amount = if (target == PaykitAsset.BTC) converted?.atomic ?: 0u else it.amount, + paykitAmount = if (target == PaykitAsset.USDT) converted?.value.orEmpty() else it.paykitAmount + ) + } + selectFundingSource(nextSource, current) _sendUiState.update { - it.copy(isFundingSourceLoading = nextSource is SendFundingSource.Hardware) + it.copy( + isAmountInputValid = if (it.paykitUsesUsdt) { + validUsdtAmount( + it.paykitAmount + ) + } else { + validateAmount(it.amount) + }, + ) + } + updateCanSwitchWallet() + } + + private fun paymentAmountForSource(current: SendUiState, target: PaykitAsset): PaykitAmount? { + val input = activeIncomingPaymentRequest()?.amount ?: if (current.paykitUsesUsdt) { + runCatching { PaykitAmount.parse(PaykitAsset.USDT, current.paykitAmount) }.getOrNull() + } else { + PaykitAmount(PaykitAsset.BTC, current.amount) } + return activeIncomingPaymentRequest()?.payment(target, Clock.System.now())?.amount + ?: input?.takeIf { it.atomic > 0u } + ?.convertedTo(target, currencyRepo.currencyState.value.paykitRate, nowMillis()) + } + + private suspend fun selectFundingSource(nextSource: SendFundingSource, current: SendUiState) { when (nextSource) { + SendFundingSource.Usdt -> _sendUiState.update { + it.copy( + hardwareWalletId = null, + hardwareWalletName = null + ) + } + SendFundingSource.Spending -> { _sendUiState.update { it.copy( @@ -3196,12 +3416,6 @@ class AppViewModel @Inject constructor( is SendFundingSource.Hardware -> selectHardwareFundingSource(nextSource.walletId, current) } - _sendUiState.update { - it.copy( - isAmountInputValid = validateAmount(it.amount), - ) - } - updateCanSwitchWallet() } private suspend fun selectHardwareFundingSource(walletId: String, current: SendUiState) { @@ -3269,7 +3483,7 @@ class AppViewModel @Inject constructor( } private suspend fun onAmountContinue() { - if (_sendUiState.value.isLoading) return + if (_sendUiState.value.isLoading || !reviewPaykitAmount()) return _sendUiState.update { it.copy( selectedUtxos = null, @@ -3310,6 +3524,54 @@ class AppViewModel @Inject constructor( setSendEffect(SendEffect.NavigateToConfirm) } + private suspend fun reviewPaykitAmount(): Boolean { + val paykit = synchronized(contactPaymentContextLock) { activeContactPaymentContext } + if (paykit == null || paykit.endpoints.isEmpty()) return true + val current = _sendUiState.value + var terms: PaykitRequestPayment? = null + val payment = try { + val amount = enteredPaykitAmount(current) + terms = paykit.incomingPaymentRequest?.payment(amount.asset, Clock.System.now()) + if (terms?.isValid(Clock.System.now()) == false) throw PaykitAmountError.RateUnavailable + terms?.amount ?: amount + } catch (_: PaykitAmountError.RateUnavailable) { + _sendUiState.update { it.copy(paykitRateUnavailable = true, isAmountInputValid = false) } + return false + } catch (_: PaykitAmountError) { + _sendUiState.update { it.copy(paykitRateUnavailable = false, isAmountInputValid = false) } + return false + } + paykit.incomingPaymentRequest?.let { + val expected = payment + val displayed = enteredPaykitAmount(current) + if (expected != displayed) { + _sendUiState.update { state -> + state.copy( + amount = if (payment.asset == PaykitAsset.BTC) expected.atomic else state.amount, + paykitAmount = if (payment.asset == PaykitAsset.USDT) expected.value else state.paykitAmount, + paykitRateUnavailable = false, + isAmountInputValid = if (payment.asset == PaykitAsset.USDT) { + validUsdtAmount(expected.value) + } else { + validateAmount(expected.atomic) + }, + ) + } + return false + } + } + paykitReviewedAmount = payment + paykitPaymentTerms = terms + if (current.paykitUsesUsdt) setSendEffect(SendEffect.NavigateToUsdtReview) + return !current.paykitUsesUsdt + } + + private fun enteredPaykitAmount(current: SendUiState): PaykitAmount = if (current.paykitUsesUsdt) { + PaykitAmount.parse(PaykitAsset.USDT, current.paykitAmount) + } else { + PaykitAmount(PaykitAsset.BTC, current.amount) + } + private suspend fun prepareHardwareSendFee(): Boolean { val state = _sendUiState.value val walletId = state.hardwareWalletId ?: return true @@ -3447,6 +3709,7 @@ class AppViewModel @Inject constructor( incomingPaymentRequest: PaykitPaymentRequest? = null, isInitialSubscriptionPayment: Boolean = false, selectedTags: ImmutableList = persistentListOf(), + endpoints: List = emptyList(), ): Job? { val context = ContactPaymentContext( publicKey = publicKey, @@ -3454,6 +3717,7 @@ class AppViewModel @Inject constructor( incomingPaymentRequest = incomingPaymentRequest, isInitialSubscriptionPayment = isInitialSubscriptionPayment, selectedTags = selectedTags, + endpoints = endpoints, ) return launchScan( source = ScanSource.SCAN_RESULT, @@ -3483,18 +3747,7 @@ class AppViewModel @Inject constructor( ) = withContext(bgDispatcher) { if (rejectPubkyAuthScan(result, allowPubkyAuth, contactPaymentContext)) return@withContext - val input = if (routePubkyKeys && PubkyContactLink.matches(Uri.parse(result))) { - PubkyContactLink.publicKey(Uri.parse(result)) ?: run { - toast( - type = Toast.ToastType.ERROR, - title = context.getString(R.string.other__scan_err_decoding), - description = context.getString(R.string.other__scan__error__generic), - ) - return@withContext - } - } else { - result.removeLightningSchemes() - } + val input = normalizedScanInput(result, routePubkyKeys) ?: return@withContext val contactPaymentProfile = activeContactPaymentProfile() val incomingPaymentRequest = activeIncomingPaymentRequest() @@ -3516,6 +3769,10 @@ class AppViewModel @Inject constructor( resetQuickPay() val fromMainScanner = isMainScanner + if (contactPaymentContext != null && requiresPaykitAssetSelection(contactPaymentContext)) { + openPaykitEndpoints(contactPaymentContext, fromMainScanner) + return@withContext + } // TODO Workaround for https://github.com/synonymdev/bitkit-core/issues/63 if (Bip21Utils.isDuplicatedBip21(input)) { @@ -3593,6 +3850,27 @@ class AppViewModel @Inject constructor( handleDecodedScan(scan, input, fromMainScanner, suppressQuickPay) } + private fun normalizedScanInput(result: String, routePubkyKeys: Boolean): String? { + return if (routePubkyKeys && PubkyContactLink.matches(Uri.parse(result))) { + PubkyContactLink.publicKey(Uri.parse(result)) ?: run { + toast( + type = Toast.ToastType.ERROR, + title = context.getString(R.string.other__scan_err_decoding), + description = context.getString(R.string.other__scan__error__generic), + ) + return null + } + } else { + result.removeLightningSchemes() + } + } + + private fun requiresPaykitAssetSelection(payment: ContactPaymentContext): Boolean = + payment.endpoints.isNotEmpty() && ( + payment.endpoints.any { it.methodId == MethodId.UsdtArbitrum } || + payment.incomingPaymentRequest?.let { it.amount.asset != PaykitAsset.BTC } == true + ) + private fun logDecodedScan(scan: Scanner, isPaymentRequest: Boolean) { if (isPaymentRequest) { Logger.info("Decoded incoming Paykit payment request target", context = TAG) @@ -3885,7 +4163,11 @@ class AppViewModel @Inject constructor( } else { null } - val amount = incomingPaymentRequest?.amountSats + val amount = incomingPaymentRequest?.let { + runCatching { + it.payment(PaykitAsset.BTC, Clock.System.now()).amount.atomic + }.getOrNull() + } ?: lnInvoice?.amountSatoshis?.takeIf { it > 0uL } ?: invoice.amountSatoshis _sendUiState.update { @@ -4088,7 +4370,16 @@ class AppViewModel @Inject constructor( state.hardwareWalletId?.let { add(SendFundingSource.Hardware(it)) } return@buildList } - if (state.isUnified || state.decodedInvoice != null) add(SendFundingSource.Spending) + if (activeIncomingPaymentRequest()?.let { paykitUsdtPayments.hasBinding(it.id) } == true) { + if (state.usdtRecipient != null) add(SendFundingSource.Usdt) + return@buildList + } + if (state.usdtRecipient != null) add(SendFundingSource.Usdt) + if (state.isUnified || state.decodedInvoice != null || state.lnurl is LnurlParams.LnurlPay) { + add( + SendFundingSource.Spending + ) + } if (state.address.isNotEmpty()) { add(SendFundingSource.Savings) hwWalletRepo.wallets.value.forEach { wallet -> @@ -4100,6 +4391,7 @@ class AppViewModel @Inject constructor( } private fun SendUiState.selectedFundingSource(): SendFundingSource = when { + paykitUsesUsdt -> SendFundingSource.Usdt hardwareWalletId != null -> SendFundingSource.Hardware(hardwareWalletId) payMethod == SendMethod.LIGHTNING -> SendFundingSource.Spending else -> SendFundingSource.Savings @@ -4134,7 +4426,11 @@ class AppViewModel @Inject constructor( return } - val amount = incomingPaymentRequest?.amountSats ?: invoice.amountSatoshis + val amount = incomingPaymentRequest?.let { + runCatching { + it.payment(PaykitAsset.BTC, Clock.System.now()).amount.atomic + }.getOrNull() + } ?: invoice.amountSatoshis val quickPayHandled = handleQuickPayIfApplicable( amountSats = amount, invoice = invoice, @@ -4198,7 +4494,11 @@ class AppViewModel @Inject constructor( val isFixed = data.isFixedAmount() val displaySats = data.minSendableSat() - val incomingAmount = activeIncomingPaymentRequest()?.amountSats + val incomingAmount = activeIncomingPaymentRequest()?.let { + runCatching { + it.payment(PaykitAsset.BTC, Clock.System.now()).amount.atomic + }.getOrNull() + } if (incomingAmount != null && incomingAmount !in displaySats..data.maxSendableSat()) { if (clearIncomingPaymentRequestTarget()) return toast( @@ -4310,13 +4610,14 @@ class AppViewModel @Inject constructor( effect: SendEffect, ) { val preparation = paymentRequestPreparation.value - if (preparation != null && route == SendRoute.Confirm) { + if (preparation != null) { if (!ownsPaymentRequestPreparation(preparation)) return if (activeIncomingPaymentRequest()?.id != preparation.request.id) return - paymentRequestPreparation.compareAndSet(preparation, null) + if (!paymentRequestPreparation.compareAndSet(preparation, null)) return _currentSheet.update { if (it === preparation.sheet) preparation.sheet.copy(preparingRequest = null) else it } + if (route != SendRoute.Confirm) setSendEffect(effect) return } if (fromMainScanner) { @@ -5188,6 +5489,7 @@ class AppViewModel @Inject constructor( paymentEndpointIdentifier = preparation.endpointIdentifier, paymentAppId = preparation.appId, kind = preparation.kind, + paymentTerms = paykitPaymentTerms, ).map { request } } @@ -5213,6 +5515,7 @@ class AppViewModel @Inject constructor( ) { val paymentRequest = request ?: return if (preparation == null) return + val quoteId = paykitPaymentTerms?.quoteId viewModelScope.launch { paykitPaymentProofRepo.completeOnchainPayment( request = paymentRequest, @@ -5220,6 +5523,7 @@ class AppViewModel @Inject constructor( paymentEndpointIdentifier = preparation.endpointIdentifier, paymentAppId = preparation.appId, acceptedOutcome = acceptedOutcome, + conversionQuoteId = quoteId, ) if (paymentRequest.billingPeriod != null) refreshIncomingPaykitPaymentRequests() } @@ -5267,23 +5571,45 @@ class AppViewModel @Inject constructor( private suspend fun hasMismatchedIncomingPaymentRequest(contactPaymentContext: ContactPaymentContext?): Boolean { val incomingPaymentRequest = contactPaymentContext?.incomingPaymentRequest ?: return false - if (!incomingPaymentRequest.acceptsPaymentAmount(_sendUiState.value.amount)) return true - if (_sendUiState.value.payMethod != SendMethod.LIGHTNING) return false - - val lightningInvoice = _sendUiState.value.decodedInvoice ?: return false - return !incomingPaymentRequest.acceptsLightningInvoice(lightningInvoice) + if (_sendUiState.value.paykitUsesUsdt) { + return runCatching { + val terms = incomingPaymentRequest.payment( + PaykitAsset.USDT, + Clock.System.now(), + paykitPaymentTerms?.quoteId + ) + terms != paykitPaymentTerms || !terms.isValid(Clock.System.now()) || + terms.amount != paykitReviewedAmount + }.getOrDefault(true) + } + if (!incomingPaymentRequest.acceptsPaymentAmount( + _sendUiState.value.amount, + paykitPaymentTerms, + Clock.System.now() + ) + ) { + return true + } + return _sendUiState.value.payMethod == SendMethod.LIGHTNING && + _sendUiState.value.decodedInvoice?.let { !incomingPaymentRequest.acceptsLightningInvoice(it) } == true } private suspend fun PaykitPaymentRequest.acceptsLightningInvoice(invoice: LightningInvoice): Boolean = withContext(bgDispatcher) { val amountMsats = runCatching { Bolt11Invoice.fromStr(invoice.bolt11).amountMilliSatoshis() } .getOrElse { return@withContext false } - acceptsLightningInvoiceAmountMsats(amountMsats) + acceptsLightningInvoiceAmountMsats(amountMsats, paykitPaymentTerms, Clock.System.now()) } private suspend fun validateIncomingPaymentRequest( contactPaymentContext: ContactPaymentContext?, ): Boolean { + if (!_sendUiState.value.paykitUsesUsdt && + contactPaymentContext?.incomingPaymentRequest?.let { paykitUsdtPayments.hasBinding(it.id) } == true + ) { + rejectMismatchedPaymentRequest() + return false + } val incomingPaymentRequest = contactPaymentContext?.incomingPaymentRequest if ( (_sendUiState.value.isPaymentRequest && incomingPaymentRequest == null) || @@ -5446,7 +5772,7 @@ class AppViewModel @Inject constructor( sats = amount, speed = _sendUiState.value.speed, utxosToSpend = _sendUiState.value.selectedUtxos, - isMaxAmount = _sendUiState.value.payMethod == SendMethod.ONCHAIN && + isMaxAmount = activeIncomingPaymentRequest() == null && _sendUiState.value.payMethod == SendMethod.ONCHAIN && amount == walletRepo.balanceState.value.maxSendOnchainSats, tags = tags, requestId = requestId, @@ -5683,6 +6009,8 @@ class AppViewModel @Inject constructor( ) { sendStateGeneration++ addressValidationJob?.cancel() + paykitReviewedAmount = null + paykitPaymentTerms = null val speed = settingsStore.data.first().defaultTransactionSpeed val rates = let { // Refresh blocktank info to get latest fee rates @@ -6363,6 +6691,7 @@ class AppViewModel @Inject constructor( private suspend fun consumePrivatePaymentListIfNeeded(context: ContactPaymentContext?): Result { context ?: return Result.success(Unit) + if (_sendUiState.value.paykitUsesUsdt) return Result.success(Unit) val privatePaymentContext = context.privatePaymentContext ?: return Result.success(Unit) return privatePaykitRepo.consumePrivatePaymentList(context.publicKey, privatePaymentContext) } @@ -6432,6 +6761,7 @@ class AppViewModel @Inject constructor( publicKey = acceptedDueRequest.counterparty, privatePaymentContext = resolution.privatePaymentContext, incomingPaymentRequest = acceptedDueRequest, + endpoints = resolution.endpoints, isInitialSubscriptionPayment = true, ) scanJob?.join() @@ -6607,6 +6937,7 @@ class AppViewModel @Inject constructor( publicKey = request.counterparty, privatePaymentContext = resolution.privatePaymentContext, incomingPaymentRequest = request, + endpoints = resolution.endpoints, isInitialSubscriptionPayment = true, selectedTags = tags, ) @@ -7040,6 +7371,10 @@ data class SendUiState( val contactPaymentProfile: PubkyProfile? = null, val isPaymentRequest: Boolean = false, val paymentRequestNote: String? = null, + val paykitUsesUsdt: Boolean = false, + val paykitRateUnavailable: Boolean = false, + val paykitAmount: String = "", + val usdtRecipient: String? = null, val hardwareWalletId: String? = null, val resolvedHardwarePaymentTxId: String? = null, val isRetainedHardwarePayment: Boolean = false, @@ -7077,6 +7412,7 @@ enum class SendMethod { ONCHAIN, LIGHTNING } private sealed interface SendFundingSource { data object Spending : SendFundingSource data object Savings : SendFundingSource + data object Usdt : SendFundingSource data class Hardware(val walletId: String) : SendFundingSource } @@ -7086,6 +7422,7 @@ data class ContactPaymentContext( val incomingPaymentRequest: PaykitPaymentRequest? = null, val isInitialSubscriptionPayment: Boolean = false, val selectedTags: ImmutableList = persistentListOf(), + val endpoints: List = emptyList(), ) private data class PaymentProofPreparation( @@ -7115,6 +7452,7 @@ sealed class SendEffect { data object NavigateToAmount : SendEffect() data object NavigateToScan : SendEffect() data object NavigateToConfirm : SendEffect() + data object NavigateToUsdtReview : SendEffect() data object NavigateToHardwareSign : SendEffect() data object NavigateToWithdrawConfirm : SendEffect() data object NavigateToWithdrawError : SendEffect() diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index ae1a35d637..d3da863887 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -658,15 +658,28 @@ Details OK This service will manage your private Paykit data and send Paykit messages for you. Your pubky secret and wallet keys stay private. + Separate watch-only account · xpub + Paykit access + PAYMENT DETAILS TO SHARE + Share a separate Bitcoin account and your existing USDT address to receive earnings. Sharing these details does not let the service spend your funds. + <accent>EARN BITCOIN\nAND USDT</accent>\nFROM YOUR CONTENT Requested permissions A service is requesting permission to access and edit your <accent>%1$s</accent> data. <accent>%1$s</accent> is requesting permission to access and edit your <accent>%2$s</accent> data. Unknown service + Your Bitcoin watch-only account was shared. + Your Bitcoin watch-only account and USDT receiving address were shared. + Your USDT receiving address was shared. Authorization Successful You authorized with pubky <accent>%1$s</accent> and gave the service permission to access and edit your <accent>%2$s</accent> data. You authorized with pubky <accent>%1$s</accent> and gave <accent>%2$s</accent> permission to access and edit your <accent>%3$s</accent> data. Authorize Make sure you trust the service, browser, and device before authorizing with your pubky. + Share your existing USDT address on Arbitrum One to receive earnings directly in Bitkit. The service cannot spend your funds. + <accent>EARN USDT</accent>\nFROM YOUR\nCONTENT + Loading USDT address… + This is your existing USDT account. The service can see its balance and transaction history, but cannot spend your funds. + Your USDT address is unavailable. Try again before authorizing. %1$s server Approve To earn, you need to share a watch-only Bitcoin account with Paykit. It can view sales activity, but cannot spend funds. @@ -1205,6 +1218,82 @@ Total %1$s, %2$d UTXO %1$s, %2$d UTXOs + Activity + Recipient address + Amount (USDT) + Balance + Bridge needs attention + Your payment is pending. You can track confirmation and cross-network delivery in Activity. + Delivering to destination + Confirmed + Deposit amount + Amount outside deposit limits. + This deposit needs provider assistance. Contact Bitkit support with the deposit reference. + The deposit service could not verify this request. Try again. + Converted batch + Estimated deduction (USDT) + Get Deposit Address + No deposits yet. + Estimated received (USDT) + Indicative price only. Costs are deducted from the USDT received and may change before conversion. The sender pays their network gas separately. + Fees are deducted from your deposit. + Cross-network Deposits + Deposit limits + Live liquidity and network costs can further restrict these limits. Amounts outside the limits may be held. + Load more + Needs attention + Deposit details changed. Refresh the deposit history and select it again. + Send only USDT on the selected network. Orchestra delivers USDT0 to your Arbitrum One wallet. This address is reusable; pricing is set when each deposit is processed. Deposits may be held for review. + Deposit reference + Refresh + Request Refund + Refund address on the source network + Confirm a refund address with the sender. Do not assume an exchange deposit can be returned to its sending address. Refund fees may apply. TRON refunds can require Orchestra operator assistance. + Refund requested. This is not a confirmed refund; check the deposit status. + Refunded + Refund in progress + Provider status is shown here. Your spendable balance updates only when USDT arrives on Arbitrum. + Cross-network receiving is currently unavailable. Direct Arbitrum receive still works. + Unsupported deposit asset — contact support + Recipient network + Enter a valid address for the selected network. + Enter a valid amount with up to 6 decimal places. + Unable to back up this payment. It will be retried when backup is available. + Not enough USDT to cover the amount and fees. + Set your device date and time automatically, then try again. + USDT is currently unavailable. Please try again later. + This address uses another wallet’s smart account. Disable its smart account mode there before sending with Bitkit. + The fee quote expired. Review the payment again. + Could not update USDT. Check your connection and try again. + A payment is still pending. Wait for confirmation before sending again. + Too many requests. Please try again shortly. + The USDT network rejected the request. Please try again. + The USDT service returned an invalid response. Please try again later. + This network is currently unavailable. + Could not access USDT wallet data. Please try again. + Could not access your USDT wallet. Reopen Bitkit and try again. + Expected amount + Failed + All fees are paid in USDT. The final network fee may be lower than this maximum. + Older activity is still syncing. Your balance is up to date when the connection is available. + Maximum fee + Select the network used by the recipient. Sending to an address on the wrong network can lose funds. + Received USDT + USDT Sent + Pending + Receive + Receive USDT + Receive USDT on Arbitrum One only. Bridge funds from other networks before sending. + Received + Recipient gets + Replaced by another payment + Send + Your payment was not completed. Check Activity for details. + Send USDT + Sent + Payment submitted + Your payment is being processed. You can track its status in Activity. + Track cross-network delivery Activity Address All Activity @@ -1234,6 +1323,12 @@ Failed Fee Fee (prepaid) + Earlier + This month + Today + This week + This year + Yesterday {count, plural, one {INPUT} other {INPUTS (#)}} Invoice Invoice note @@ -1602,4 +1697,17 @@ Small Wide Widgets + Payment rates are unavailable or expired. Try again when online. + Accept payment with + Payment verified + Received · Review needed + Received · Underpaid + Received · After expiry + Bridge + Estimated bridge cost (included) + Maximum total debit + Delivery is estimated. Bridge costs are deducted from the amount; the network fee is additional. + USDT was returned to your wallet. See details for the refunded amount. + Destination transaction + Refund transaction diff --git a/app/src/test/java/to/bitkit/models/PaykitAmountTest.kt b/app/src/test/java/to/bitkit/models/PaykitAmountTest.kt new file mode 100644 index 0000000000..4a48bd4c6c --- /dev/null +++ b/app/src/test/java/to/bitkit/models/PaykitAmountTest.kt @@ -0,0 +1,53 @@ +package to.bitkit.models + +import org.junit.Test +import kotlin.test.assertEquals +import kotlin.test.assertFailsWith + +class PaykitAmountTest { + private val now = 1_800_000_000_000L + private val rate = PaykitExchangeRate("100000", now) + + @Test + fun `conversion preserves value and rounds payment atomic units upward`() { + data class Case(val source: PaykitAsset, val value: String, val target: PaykitAsset, val expected: String) + val cases = listOf( + Case(PaykitAsset.USD, "5", PaykitAsset.USDT, "5"), + Case(PaykitAsset.USDT, "5.000001", PaykitAsset.USD, "5.01"), + Case(PaykitAsset.BTC, "0.00000001", PaykitAsset.USDT, "0.001"), + Case(PaykitAsset.USD, "5", PaykitAsset.BTC, "0.00005"), + Case(PaykitAsset.USDT, "0.000001", PaykitAsset.BTC, "0.00000001"), + ) + cases.forEach { + assertEquals(it.expected, PaykitAmount.parse(it.source, it.value).convertedTo(it.target, rate, now).value) + } + } + + @Test + fun `stale missing and future rates block only bitcoin conversions`() { + val amount = PaykitAmount.parse(PaykitAsset.USD, "5") + listOf( + null, + rate.copy(timestampMillis = now - 600001), + rate.copy(timestampMillis = now + 1), + rate.copy(price = "0"), + rate.copy(price = "NaN") + ).forEach { invalid -> + assertFailsWith { amount.convertedTo(PaykitAsset.BTC, invalid, now) } + assertEquals("5", amount.convertedTo(PaykitAsset.USDT, invalid, now).value) + } + assertEquals( + "0.00005", + amount.convertedTo(PaykitAsset.BTC, rate.copy(timestampMillis = now - 600000), now).value + ) + } + + @Test + fun `amount parsing enforces positive exact decimals and atomic bounds`() { + listOf("", "0", "-1", "+1", "1e2", "1,2", ".5", "5.", "0.0000001", "18446744073710").forEach { + assertFailsWith { PaykitAmount.parse(PaykitAsset.USDT, it) } + } + assertEquals("1.23", PaykitAmount.parse(PaykitAsset.USDT, "01.23000000").value) + assertEquals(ULong.MAX_VALUE, PaykitAmount.parse(PaykitAsset.USDT, "18446744073709.551615").atomic) + } +} diff --git a/app/src/test/java/to/bitkit/models/PaykitPaymentStateBackupTest.kt b/app/src/test/java/to/bitkit/models/PaykitPaymentStateBackupTest.kt index b3da7c259e..8758e8a2d0 100644 --- a/app/src/test/java/to/bitkit/models/PaykitPaymentStateBackupTest.kt +++ b/app/src/test/java/to/bitkit/models/PaykitPaymentStateBackupTest.kt @@ -51,6 +51,36 @@ class PaykitPaymentStateBackupTest { assertContains(codec.encodeToString(decoded), "\"activeOnchainAttempt\"") } + @Test + fun `wallet envelope preserves core recovery data`() { + val fixture = """ + {"version":1,"createdAt":1,"transfers":[], + "usdtWallet":"{\"identity\":\"42161:wallet\",\"transfers\":[]}"} + """.trimIndent() + val decoded = Json.decodeFromString(fixture) + assertEquals("""{"identity":"42161:wallet","transfers":[]}""", decoded.usdtWallet) + assertEquals(decoded, Json.decodeFromString(Json.encodeToString(decoded))) + val withoutUsdt = """{"version":1,"createdAt":1,"transfers":[]}""" + assertEquals(null, Json.decodeFromString(withoutUsdt).usdtWallet) + } + + @Test + fun `usdt backup preserves shared wire format`() { + val fixture = usdtBackupFixture + val backup = Json.decodeFromString(fixture) + val attempt = backup.attempts.single() + val receipt = backup.receipts.single().restored() + assertTrue(attempt.paymentStarted) + assertEquals("bitkit", attempt.binding?.paymentAppId) + assertEquals("quote", attempt.binding?.conversionQuoteId) + assertEquals("2026-10-01T00:00:00.125Z", attempt.billingPeriod?.sdkValue?.startsAt) + assertEquals(50_000uL, receipt.amount.atomic) + assertEquals(attempt.requestId, receipt.requestId) + val rebuilt = PaykitUsdtStateBackup(listOf(attempt), listOf(PaykitUsdtStateBackup.Receipt(receipt))) + val json = Json { encodeDefaults = true } + assertEquals(json.parseToJsonElement(fixture), json.parseToJsonElement(json.encodeToString(rebuilt))) + } + @Test fun `payment backup accepts shared wire format and retains pending payment`() { WalletScope.pushTestOverride("wallet0").use { @@ -102,4 +132,58 @@ class PaykitPaymentStateBackupTest { assertFailsWith { unknownKind.pendingProofs.single().restored() } } } + private val usdtBackupFixture = """ + { + "attempts": [ + { + "quoteId": "operation", + "wallet": "wallet", + "identity": "alice", + "contact": "bob", + "requestId": { + "paymentRequestId": "request", + "counterparty": "bob", + "billingPeriodStartsAt": "2026-10-01T00:00:00.125Z" + }, + "binding": { + "payer": "alice", + "payee": "bob", + "paymentAppId": "bitkit", + "paymentRequestId": "request", + "paymentReference": "invoice", + "paymentEndpointIdentifier": "usdt-arbitrum-address", + "periodStartsAt": "2026-10-01T00:00:00.125Z", + "periodEndsAt": "2026-11-01T00:00:00.125Z", + "conversionQuoteId": "quote" + }, + "billingPeriod": { + "startsAt": "2026-10-01T00:00:00.125Z", + "endsAt": "2026-11-01T00:00:00.125Z" + }, + "proof": null, + "proofQueued": false, + "paymentStarted": true + } + ], + "receipts": [ + { + "wallet": "wallet", + "identity": "alice", + "requestId": { + "paymentRequestId": "request", + "counterparty": "bob", + "billingPeriodStartsAt": "2026-10-01T00:00:00.125Z" + }, + "paymentId": "42161:transaction:2", + "proofEventId": "proof", + "verified": true, + "transferId": "transfer", + "amountAtomic": 50000, + "receivedAtMillis": 1790812801000, + "underpaid": false, + "afterExpiry": false + } + ] + } + """.trimIndent() } diff --git a/app/src/test/java/to/bitkit/models/PaykitRequestPricingTest.kt b/app/src/test/java/to/bitkit/models/PaykitRequestPricingTest.kt new file mode 100644 index 0000000000..aee6552478 --- /dev/null +++ b/app/src/test/java/to/bitkit/models/PaykitRequestPricingTest.kt @@ -0,0 +1,123 @@ +@file:OptIn(kotlin.time.ExperimentalTime::class) + +package to.bitkit.models + +import com.synonym.paykit.ConversionRate +import com.synonym.paykit.PaymentConversion +import com.synonym.paykit.PaymentConversionQuoteRecord +import com.synonym.paykit.PaymentDeadline +import org.junit.Test +import to.bitkit.repositories.MethodId +import to.bitkit.repositories.PaykitBillingPeriod +import kotlin.test.assertEquals +import kotlin.test.assertFails +import kotlin.test.assertFalse +import kotlin.test.assertTrue +import kotlin.time.Duration.Companion.seconds +import kotlin.time.Instant + +class PaykitRequestPricingTest { + private val now = Instant.fromEpochSeconds(1_800_000_000) + + @Test fun `fixed rates determine exact amounts without market rates`() { + val pricing = PaykitRequestPricing( + PaymentConversion.Fixed( + listOf( + ConversionRate("btc", "0.000012345"), + ConversionRate("usdt", "1"), + ) + ) + ) + val requested = PaykitAmount.parse(PaykitAsset.USD, "0.05") + assertEquals(62uL, pricing.payment(requested, PaykitAsset.BTC, null, now).amount.atomic) + assertEquals(50_000uL, pricing.payment(requested, PaykitAsset.USDT, null, now).amount.atomic) + assertEquals(requested, pricing.payment(requested, PaykitAsset.USD, null, now).amount) + assertFails { pricing.payment(requested, PaykitAsset.USDT, null, now, "unknown") } + } + + @Test fun `subscriptions keep one payment currency across billing periods`() { + val bitcoin = MethodId.P2wpkh.rawValue + val lightning = MethodId.Bolt11.rawValue + val usdt = MethodId.UsdtArbitrum.rawValue + val available = listOf(bitcoin, lightning, usdt) + for ((asset, endpoints, paidAsset) in listOf( + Triple(PaykitAsset.BTC, listOf(bitcoin, lightning), PaykitAsset.BTC), + Triple(PaykitAsset.USD, listOf(usdt), PaykitAsset.USDT), + )) { + val selected = PaykitRequestPricing.subscriptionEndpoints(asset, available) + assertEquals(endpoints, selected) + assertTrue(PaykitRequestPricing.subscriptionEndpoints(asset, available - endpoints.toSet()).isEmpty()) + val rates = PaykitRequestPricing.rates(asset, selected, null, now) + val pricing = PaykitRequestPricing(rates.takeIf { it.isNotEmpty() }?.let(PaymentConversion::Fixed)) + val requested = PaykitAmount.parse(asset, "5") + val period = PaykitBillingPeriod(now + (31 * 86400).seconds, now + (62 * 86400).seconds) + val payment = pricing.payment(requested, paidAsset, period, period.startsAt) + assertEquals("5", payment.amount.value) + assertEquals(null, payment.quoteId) + assertEquals(null, payment.expiresAt) + assertTrue(payment.isValid(period.endsAt)) + } + assertTrue(PaykitRequestPricing.subscriptionEndpoints(PaykitAsset.USDT, available).isEmpty()) + } + + @Test fun `missing terms or rate never implicitly enable conversion`() { + val requested = PaykitAmount.parse(PaykitAsset.USD, "5") + for (pricing in listOf( + PaykitRequestPricing(), + PaykitRequestPricing(PaymentConversion.Fixed(listOf(ConversionRate("btc", "0.00001")))) + )) { + assertFails { pricing.payment(requested, PaykitAsset.USDT, null, now) } + assertEquals(requested, pricing.payment(requested, PaykitAsset.USD, null, now).amount) + } + } + + @Test fun `quoted arithmetic rejects overflow and rounds only once`() { + val requested = PaykitAmount.parse(PaykitAsset.BTC, "0.00000001") + assertEquals(1235uL, requested.quotedTo(PaykitAsset.USDT, "123456.789012345678").atomic) + assertFails { PaykitAmount(PaykitAsset.USDT, ULong.MAX_VALUE).quotedTo(PaykitAsset.USDT, "2") } + for (rate in listOf("0", "-1", "NaN", "1e2", "0.123456789012345678901234567890123456789")) { + assertFails { requested.quotedTo(PaykitAsset.USDT, rate) } + } + } + + @Test fun `rates are required only when issuing bitcoin conversions`() { + val usdt = MethodId.UsdtArbitrum.rawValue + assertEquals( + listOf(ConversionRate("usdt", "1")), + PaykitRequestPricing.rates(PaykitAsset.USD, listOf(usdt), null, now) + ) + assertFails { PaykitRequestPricing.rates(PaykitAsset.BTC, listOf(usdt), null, now) } + val stale = PaykitExchangeRate("100000", now.toEpochMilliseconds() - 601000) + assertFails { PaykitRequestPricing.rates(PaykitAsset.BTC, listOf(usdt), stale, now) } + } + + @Test fun `recurring payments keep their chosen quote and inclusive deadline`() { + val period = PaykitBillingPeriod(now, now + 86400.seconds) + val first = PaymentConversionQuoteRecord( + "first", + period.sdkValue, + listOf(ConversionRate("usdt", "100000")), + now.toString(), + (now + 60.seconds).toString(), + null + ) + val later = first.copy(eventId = "later", rates = listOf(ConversionRate("usdt", "110000"))) + val pricing = PaykitRequestPricing( + PaymentConversion.PerPeriod, + PaymentDeadline.PeriodStart(30u), + listOf(first, later) + ) + val requested = PaykitAmount.parse(PaykitAsset.BTC, "0.00001") + val selected = pricing.payment(requested, PaykitAsset.USDT, period, now) + assertEquals("1.1", selected.amount.value) + assertEquals("later", selected.quoteId) + val pinned = pricing.payment(requested, PaykitAsset.USDT, period, now, "first") + assertEquals("1", pinned.amount.value) + assertTrue(pinned.isValid(now + 30.seconds)) + assertFalse(pinned.isValid(now + 31.seconds)) + assertFalse(pinned.isValid(now - 1.seconds)) + assertEquals(pinned, pricing.payment(requested, PaykitAsset.USDT, period, now + 600.seconds, "first")) + assertFails { pricing.payment(requested, PaykitAsset.USDT, period, now, "missing") } + assertFails { pricing.payment(requested, PaykitAsset.USDT, null, now) } + } +} diff --git a/app/src/test/java/to/bitkit/repositories/BackupRepoTest.kt b/app/src/test/java/to/bitkit/repositories/BackupRepoTest.kt index 685da84e68..8b921e3e7f 100644 --- a/app/src/test/java/to/bitkit/repositories/BackupRepoTest.kt +++ b/app/src/test/java/to/bitkit/repositories/BackupRepoTest.kt @@ -9,6 +9,7 @@ import kotlinx.coroutines.launch import kotlinx.coroutines.flow.first import kotlinx.coroutines.cancelAndJoin import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.async import kotlinx.coroutines.flow.MutableSharedFlow import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.update @@ -96,6 +97,8 @@ class BackupRepoTest : BaseUnitTest() { private val privatePaykitRepo = mock() private val privatePaykitAddressReservationRepo = mock() private val paykitPaymentProofRepo = mock() + private val usdtRepo = mock() + private val paykitUsdtPaymentRepo = mock() private val paykitPaymentProofStore = mock() private val paykitPaymentRequestRepo = mock() private val paykitPresentationStore = mock() @@ -155,6 +158,7 @@ class BackupRepoTest : BaseUnitTest() { whenever { vssBackupClient.putObject(any(), any()) } .thenReturn(Result.success(VssItem(key = BackupCategory.SETTINGS.name, value = byteArrayOf(), version = 1))) whenever { vssBackupClient.setupWithRetry(any(), any(), any()) }.thenReturn(Result.success(Unit)) + whenever { vssBackupClient.setup(any()) }.thenReturn(Result.success(Unit)) whenever { vssBackupClientLdk.setup() }.thenReturn(Result.success(Unit)) whenever { transferDao.getAll() }.thenReturn(emptyList()) whenever { privatePaykitRepo.restoreBackup(anyOrNull()) }.thenReturn(Result.success(Unit)) @@ -162,6 +166,11 @@ class BackupRepoTest : BaseUnitTest() { whenever(privatePaykitRepo.backupStateVersion).thenReturn(MutableStateFlow(0L)) whenever(paykitSdkService.backupStateVersion).thenReturn(MutableStateFlow(0L)) whenever { paykitPaymentProofRepo.backupSnapshot() }.thenReturn(emptyList()) + whenever { paykitUsdtPaymentRepo.backupSnapshot() }.thenReturn( + to.bitkit.models.PaykitUsdtStateBackup(emptyList(), emptyList()) + ) + whenever(usdtRepo.state).thenReturn(MutableStateFlow(UsdtWalletState())) + whenever(paykitUsdtPaymentRepo.backupStateVersion).thenReturn(MutableStateFlow(0L)) whenever(paykitPresentationStore.backupSnapshot()).thenReturn(emptyMap()) whenever { privatePaykitAddressReservationRepo.restoreBackup(any()) }.thenReturn(Result.success(Unit)) whenever { privatePaykitAddressReservationRepo.backupSnapshot() }.thenReturn(Result.success(null)) @@ -684,6 +693,60 @@ class BackupRepoTest : BaseUnitTest() { verify(vssBackupClient, never()).putObject(eq(BackupCategory.WALLET.name), any()) } + @Test + fun `payment backup waits for earlier uploads and propagates failure`() = test { + val release = CompletableDeferred() + val uploads = mutableListOf() + var fail = false + whenever(usdtRepo.backupSnapshot()).thenReturn("older") + whenever { vssBackupClient.putObject(eq(BackupCategory.WALLET.name), any()) }.doSuspendableAnswer { + val payload = json.decodeFromString(it.getArgument(1).decodeToString()) + if (payload.usdtWallet == "older") release.await() + uploads += payload.usdtWallet + if (fail) { + Result.failure(BackupRepoTestError("offline")) + } else { + Result.success(VssItem(key = BackupCategory.WALLET.name, value = byteArrayOf(), version = 1)) + } + } + val background = async { sut.triggerBackup(BackupCategory.WALLET) } + runCurrent() + val payment = async { sut.persistWalletBackup("signed") } + runCurrent() + assertTrue(uploads.isEmpty()) + release.complete(Unit) + background.await().getOrThrow() + payment.await().getOrThrow() + assertEquals(listOf("older", "signed"), uploads.toList()) + fail = true + assertTrue(sut.persistWalletBackup("signed").isFailure) + } + + @Test + fun `payment backup retries setup before uploading`() = test { + whenever { vssBackupClient.setup(any()) } + .thenReturn(Result.failure(BackupRepoTestError("offline"))) + .thenReturn(Result.success(Unit)) + + assertTrue(sut.persistWalletBackup("signed").isFailure) + verify(vssBackupClient, never()).putObject(any(), any()) + + sut.persistWalletBackup("signed").getOrThrow() + verify(vssBackupClient, times(2)).setup(any()) + verify(vssBackupClient).putObject(eq(BackupCategory.WALLET.name), any()) + } + + @Test + fun `core restore failure retains wallet backup`() = test { + stubWalletBackup(usdtWallet = "signed") + whenever { usdtRepo.restoreBackup("signed") }.thenReturn(Result.failure(BackupRepoTestError("storage"))) + assertTrue(sut.performFullRestoreFromLatestBackup().isFailure) + val retained = argumentCaptor() + verify(keychain, times(2)).upsertString(eq(Keychain.Key.PAYKIT_PENDING_BACKUP_RESTORE.name), retained.capture()) + assertEquals("signed", json.decodeFromString(retained.lastValue).usdtWallet) + verify(vssBackupClient, never()).putObject(eq(BackupCategory.WALLET.name), any()) + } + @Test fun `start observing is skipped while wiping`() = test { sut.setWiping(true) @@ -1646,6 +1709,7 @@ class BackupRepoTest : BaseUnitTest() { watchOnlyAccounts: List? = null, watchOnlyAccountAllocationState: WatchOnlyAccountAllocationState? = null, paykitPaymentState: PaykitPaymentStateBackup? = null, + usdtWallet: String? = null, ) { val walletBackup = WalletBackupV1( createdAt = 123, @@ -1655,6 +1719,7 @@ class BackupRepoTest : BaseUnitTest() { watchOnlyAccounts = watchOnlyAccounts, watchOnlyAccountAllocationState = watchOnlyAccountAllocationState, paykitPaymentState = paykitPaymentState, + usdtWallet = usdtWallet, ) whenever { vssBackupClient.getObject(BackupCategory.WALLET.name) } .thenReturn( @@ -1722,6 +1787,8 @@ class BackupRepoTest : BaseUnitTest() { privatePaykitRepo = Provider { privatePaykitRepo }, privatePaykitAddressReservationRepo = Provider { privatePaykitAddressReservationRepo }, paykitPaymentProofRepo = Provider { paykitPaymentProofRepo }, + paykitUsdtPaymentRepo = Provider { paykitUsdtPaymentRepo }, + usdtRepo = Provider { usdtRepo }, paykitPaymentProofStore = paykitPaymentProofStore, paykitPaymentRequestRepo = Provider { paykitPaymentRequestRepo }, paykitPresentationStore = paykitPresentationStore, diff --git a/app/src/test/java/to/bitkit/repositories/PaykitPaymentProofRepoTest.kt b/app/src/test/java/to/bitkit/repositories/PaykitPaymentProofRepoTest.kt index 1982c67471..965371171c 100644 --- a/app/src/test/java/to/bitkit/repositories/PaykitPaymentProofRepoTest.kt +++ b/app/src/test/java/to/bitkit/repositories/PaykitPaymentProofRepoTest.kt @@ -58,6 +58,8 @@ import to.bitkit.models.HwFundingSignedTx import to.bitkit.models.HwFundingTransaction import to.bitkit.models.NodeLifecycleState import to.bitkit.models.PaykitPaymentStateBackup +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset import to.bitkit.models.WalletScope import to.bitkit.services.CoreService import to.bitkit.services.PaykitSdkService @@ -469,7 +471,7 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { val record = paymentRequestRecord() val request = paymentRequest(MethodId.Bolt11.rawValue) whenever(paykitSdkService.paymentRequests()).thenReturn(listOf(record)) - whenever(paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull())) + whenever(paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull(), isNull())) .thenThrow(IllegalStateException("temporary failure")) .thenReturn(record) val firstRepo = paymentProofRepo() @@ -492,6 +494,7 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { paymentEndpointIdentifier = endpointCaptor.capture(), proofJson = proofCaptor.capture(), billingPeriod = isNull(), + conversionQuoteId = isNull(), ) assertEquals(MethodId.Bolt11.rawValue, endpointCaptor.lastValue) assertEquals( @@ -559,7 +562,7 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { paymentRequestRecord(paymentRequestId = secondPaymentRequestId), ), ) - whenever(paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull())) + whenever(paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull(), isNull())) .thenThrow(IllegalStateException("temporary failure")) .thenReturn(paymentRequestRecord(paymentRequestId = secondPaymentRequestId)) @@ -573,6 +576,7 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { paymentEndpointIdentifier = any(), proofJson = any(), billingPeriod = isNull(), + conversionQuoteId = isNull(), ) assertEquals(listOf(PAYMENT_REQUEST_ID, secondPaymentRequestId), paymentRequestIdCaptor.allValues) assertEquals(listOf(PAYMENT_REQUEST_ID), storedProofs.map { it.requestId.paymentRequestId }) @@ -593,7 +597,9 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { } whenever(lightningRepo.getPayments()).thenReturn(Result.success(listOf(payment))) whenever(paykitSdkService.paymentRequests()).thenReturn(listOf(record)) - whenever(paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull())).thenReturn(record) + whenever( + paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull(), isNull()) + ).thenReturn(record) val firstRepo = paymentProofRepo() firstRepo.prepare(request, MethodId.Bolt11.rawValue, "bitkit", PaykitPaymentProofKind.Lightning).getOrThrow() @@ -611,6 +617,7 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { paymentEndpointIdentifier = any(), proofJson = proofCaptor.capture(), billingPeriod = isNull(), + conversionQuoteId = isNull(), ) assertEquals( """{"data":"$PREIMAGE","type":"${PaykitPaymentProofKind.Lightning.type}"}""", @@ -624,14 +631,16 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { val record = paymentRequestRecord() val request = paymentRequest(MethodId.Bolt11.rawValue) whenever(paykitSdkService.paymentRequests()).thenReturn(listOf(record)) - whenever(paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull())).thenReturn(record) + whenever( + paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull(), isNull()) + ).thenReturn(record) val repo = paymentProofRepo() repo.associateLightningPayment(request, PAYMENT_HASH, MethodId.Bolt11.rawValue, "bitkit").getOrThrow() repo.completeLightningPayment(PAYMENT_HASH, PREIMAGE) repo.reconcile() - verify(paykitSdkService).submitPaymentProof(any(), any(), any(), any(), any(), isNull()) + verify(paykitSdkService).submitPaymentProof(any(), any(), any(), any(), any(), isNull(), isNull()) assertTrue(storedProofs.isEmpty()) } @@ -645,7 +654,7 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { repo.completeLightningPayment(PAYMENT_HASH, "01".repeat(32)) assertNull(storedProofs.single().proofData) - verify(paykitSdkService, never()).submitPaymentProof(any(), any(), any(), any(), any(), isNull()) + verify(paykitSdkService, never()).submitPaymentProof(any(), any(), any(), any(), any(), isNull(), isNull()) } @Test @@ -668,7 +677,7 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { assertEquals(PaykitPaymentRequestError.OperationInProgress, result.exceptionOrNull()) assertTrue(storedProofs.isEmpty()) - verify(paykitSdkService, never()).submitPaymentProof(any(), any(), any(), any(), any(), isNull()) + verify(paykitSdkService, never()).submitPaymentProof(any(), any(), any(), any(), any(), isNull(), isNull()) } @Test @@ -693,7 +702,7 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { repo.failLightningPayment(PAYMENT_HASH) assertTrue(storedProofs.isEmpty()) - verify(paykitSdkService, never()).submitPaymentProof(any(), any(), any(), any(), any(), isNull()) + verify(paykitSdkService, never()).submitPaymentProof(any(), any(), any(), any(), any(), isNull(), isNull()) } @Test @@ -707,7 +716,9 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { val record = paymentRequestRecord() whenever(paykitSdkService.paymentRequests()).thenReturn(listOf(record)) whenever(lightningRepo.getPayments()).thenReturn(Result.success(emptyList())) - whenever(paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull())).thenReturn(record) + whenever( + paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull(), isNull()) + ).thenReturn(record) for (error in errors) { val request = paymentRequest(MethodId.Bolt11.rawValue) val repo = paymentProofRepo() @@ -734,7 +745,10 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { restartedRepo.reconcile() assertTrue(storedProofs.isEmpty()) } - verify(paykitSdkService, times(errors.size)).submitPaymentProof(any(), any(), any(), any(), any(), isNull()) + verify( + paykitSdkService, + times(errors.size) + ).submitPaymentProof(any(), any(), any(), any(), any(), isNull(), isNull()) } @Test @@ -767,11 +781,13 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { val request = paymentRequest(MethodId.P2wpkh.rawValue) val record = paymentRequestRecord() whenever(paykitSdkService.paymentRequests()).thenReturn(listOf(record)) - whenever(paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull())).thenReturn(record) + whenever( + paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull(), isNull()) + ).thenReturn(record) val repo = paymentProofRepo() repo.prepare(request, MethodId.P2wpkh.rawValue, "bitkit", PaykitPaymentProofKind.Onchain).getOrThrow() - repo.markOnchainPaymentStarted(request, ONCHAIN_ADDRESS).getOrThrow() + repo.markOnchainPaymentStarted(request, ONCHAIN_ADDRESS, request.amount.atomic).getOrThrow() assertTrue(storedProofs.single().paymentStarted) repo.completeOnchainPayment(request, txid, MethodId.P2wpkh.rawValue, "bitkit", OnchainSendOutcome.Accepted(txid)) repo.reconcile() @@ -785,6 +801,7 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { endpointCaptor.capture(), proofCaptor.capture(), isNull(), + conversionQuoteId = isNull(), ) assertEquals(MethodId.P2wpkh.rawValue, endpointCaptor.firstValue) assertEquals( @@ -800,7 +817,7 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { val repo = paymentProofRepo() repo.prepare(request, MethodId.P2wpkh.rawValue, "bitkit", PaykitPaymentProofKind.Onchain).getOrThrow() - repo.markOnchainPaymentStarted(request, ONCHAIN_ADDRESS).getOrThrow() + repo.markOnchainPaymentStarted(request, ONCHAIN_ADDRESS, request.amount.atomic).getOrThrow() repo.cancelPreparation(request) assertTrue(storedProofs.single().paymentStarted) @@ -812,7 +829,7 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { val repo = paymentProofRepo() repo.prepare(request, MethodId.P2wpkh.rawValue, "bitkit", PaykitPaymentProofKind.Onchain).getOrThrow() - repo.markOnchainPaymentStarted(request, ONCHAIN_ADDRESS).getOrThrow() + repo.markOnchainPaymentStarted(request, ONCHAIN_ADDRESS, request.amount.atomic).getOrThrow() repo.failOnchainPayment(request) assertTrue(storedProofs.isEmpty()) @@ -842,7 +859,7 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { val request = paymentRequest(MethodId.P2wpkh.rawValue) val repo = paymentProofRepo() repo.prepare(request, MethodId.P2wpkh.rawValue, "bitkit", PaykitPaymentProofKind.Onchain).getOrThrow() - repo.markOnchainPaymentStarted(request, ONCHAIN_ADDRESS).getOrThrow() + repo.markOnchainPaymentStarted(request, ONCHAIN_ADDRESS, request.amount.atomic).getOrThrow() whenever(paykitSdkService.identityStatus()).thenReturn(null) repo.failOnchainPayment(request) @@ -886,7 +903,7 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { val repo = paymentProofRepo() val txid = "ab".repeat(32) repo.prepare(request, MethodId.P2wpkh.rawValue, "bitkit", PaykitPaymentProofKind.Onchain).getOrThrow() - repo.markOnchainPaymentStarted(request, ONCHAIN_ADDRESS).getOrThrow() + repo.markOnchainPaymentStarted(request, ONCHAIN_ADDRESS, request.amount.atomic).getOrThrow() whenever(paykitSdkService.identityStatus()).thenReturn(null) assertFalse(repo.completeOnchainPayment(request, txid, MethodId.P2wpkh.rawValue, "bitkit", OnchainSendOutcome.Accepted(txid))) @@ -904,13 +921,15 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { val request = paymentRequest(endpoint) val record = paymentRequestRecord() whenever(paykitSdkService.paymentRequests()).thenReturn(listOf(record)) - whenever(paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull())).thenReturn(record) + whenever( + paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull(), isNull()) + ).thenReturn(record) val repo = paymentProofRepo() repo.completeOnchainPayment(request, txid, endpoint, "bitkit", OnchainSendOutcome.Accepted(txid)) repo.reconcile() - verify(paykitSdkService).submitPaymentProof(any(), any(), any(), eq(endpoint), any(), isNull()) + verify(paykitSdkService).submitPaymentProof(any(), any(), any(), eq(endpoint), any(), isNull(), isNull()) assertTrue(storedProofs.isEmpty()) } @@ -923,7 +942,9 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { val request = paymentRequest(MethodId.Bolt11.rawValue, billingPeriod = period) val record = paymentRequestRecord() whenever(paykitSdkService.paymentRequests()).thenReturn(listOf(record)) - whenever(paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), any())).thenReturn(record) + whenever( + paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), any(), isNull()) + ).thenReturn(record) val repo = paymentProofRepo() repo.prepare(request, MethodId.Bolt11.rawValue, "bitkit", PaykitPaymentProofKind.Lightning).getOrThrow() @@ -939,6 +960,7 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { paymentEndpointIdentifier = any(), proofJson = any(), billingPeriod = periodCaptor.capture(), + conversionQuoteId = isNull(), ) assertEquals(period, periodCaptor.firstValue) } @@ -964,7 +986,9 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { val record = paymentRequestRecord(listOf(existingProof)) val request = paymentRequest(MethodId.Bolt11.rawValue, billingPeriod = currentPeriod) whenever(paykitSdkService.paymentRequests()).thenReturn(listOf(record)) - whenever(paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), any())).thenReturn(record) + whenever( + paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), any(), isNull()) + ).thenReturn(record) val repo = paymentProofRepo() repo.prepare(request, MethodId.Bolt11.rawValue, "bitkit", PaykitPaymentProofKind.Lightning).getOrThrow() @@ -972,7 +996,7 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { repo.completeLightningPayment(PAYMENT_HASH, PREIMAGE) repo.reconcile() - verify(paykitSdkService).submitPaymentProof(any(), any(), any(), any(), any(), any()) + verify(paykitSdkService).submitPaymentProof(any(), any(), any(), any(), any(), any(), isNull()) } @Test @@ -1013,15 +1037,17 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { val request = paymentRequest(MethodId.P2wpkh.rawValue) val record = paymentRequestRecord() whenever(paykitSdkService.paymentRequests()).thenReturn(listOf(record)) - whenever(paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull())).thenReturn(record) + whenever( + paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull(), isNull()) + ).thenReturn(record) val repo = paymentProofRepo() repo.prepare(request, MethodId.P2wpkh.rawValue, "bitkit", PaykitPaymentProofKind.Onchain).getOrThrow() - repo.markOnchainPaymentStarted(request, ONCHAIN_ADDRESS).getOrThrow() + repo.markOnchainPaymentStarted(request, ONCHAIN_ADDRESS, request.amount.atomic).getOrThrow() shouldFailNextSave = true repo.completeOnchainPayment(request, txid, MethodId.P2wpkh.rawValue, "bitkit", OnchainSendOutcome.Accepted(txid)) - verify(paykitSdkService).submitPaymentProof(any(), any(), any(), any(), any(), isNull()) + verify(paykitSdkService).submitPaymentProof(any(), any(), any(), any(), any(), isNull(), isNull()) assertTrue(storedProofs.isEmpty()) } @@ -1031,17 +1057,17 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { val request = paymentRequest(MethodId.P2wpkh.rawValue) val record = paymentRequestRecord() whenever(paykitSdkService.paymentRequests()).thenReturn(listOf(record)) - whenever(paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull())) + whenever(paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull(), isNull())) .thenThrow(IllegalStateException("transient submission failure")) val repo = paymentProofRepo() repo.prepare(request, MethodId.P2wpkh.rawValue, "bitkit", PaykitPaymentProofKind.Onchain).getOrThrow() - repo.markOnchainPaymentStarted(request, ONCHAIN_ADDRESS).getOrThrow() + repo.markOnchainPaymentStarted(request, ONCHAIN_ADDRESS, request.amount.atomic).getOrThrow() shouldFailNextSave = true repo.completeOnchainPayment(request, txid, MethodId.P2wpkh.rawValue, "bitkit", OnchainSendOutcome.Accepted(txid)) assertEquals(txid, storedProofs.single().proofData) - verify(paykitSdkService).submitPaymentProof(any(), any(), any(), any(), any(), isNull()) + verify(paykitSdkService).submitPaymentProof(any(), any(), any(), any(), any(), isNull(), isNull()) } @Test @@ -1050,16 +1076,18 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { val request = paymentRequest(MethodId.P2wpkh.rawValue) val record = paymentRequestRecord() whenever(paykitSdkService.paymentRequests()).thenReturn(listOf(record)) - whenever(paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull())).thenReturn(record) + whenever( + paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull(), isNull()) + ).thenReturn(record) val repo = paymentProofRepo() repo.prepare(request, MethodId.P2wpkh.rawValue, "bitkit", PaykitPaymentProofKind.Onchain).getOrThrow() - repo.markOnchainPaymentStarted(request, ONCHAIN_ADDRESS).getOrThrow() + repo.markOnchainPaymentStarted(request, ONCHAIN_ADDRESS, request.amount.atomic).getOrThrow() shouldFailProofRemoval = true repo.completeOnchainPayment(request, txid, MethodId.P2wpkh.rawValue, "bitkit", OnchainSendOutcome.Accepted(txid)) repo.reconcile() - verify(paykitSdkService).submitPaymentProof(any(), any(), any(), any(), any(), isNull()) + verify(paykitSdkService).submitPaymentProof(any(), any(), any(), any(), any(), isNull(), isNull()) assertEquals(txid, storedProofs.single().proofData) } @@ -1070,11 +1098,13 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { val request = paymentRequest(endpoint) val record = paymentRequestRecord() whenever(paykitSdkService.paymentRequests()).thenReturn(listOf(record)) - whenever(paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull())).thenReturn(record) + whenever( + paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull(), isNull()) + ).thenReturn(record) val repo = paymentProofRepo() repo.prepare(request, endpoint, "bitkit", PaykitPaymentProofKind.Onchain).getOrThrow() - repo.markOnchainPaymentStarted(request, ONCHAIN_ADDRESS).getOrThrow() + repo.markOnchainPaymentStarted(request, ONCHAIN_ADDRESS, request.amount.atomic).getOrThrow() shouldFailNextLoad = true repo.completeOnchainPayment(request, txid, endpoint, "bitkit", OnchainSendOutcome.Accepted(txid)) repo.reconcile() @@ -1088,6 +1118,7 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { paymentEndpointIdentifier = endpointCaptor.capture(), proofJson = proofCaptor.capture(), billingPeriod = isNull(), + conversionQuoteId = isNull(), ) assertEquals(endpoint, endpointCaptor.firstValue) assertEquals( @@ -1103,7 +1134,7 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { val record = paymentRequestRecord() val request = paymentRequest(MethodId.P2wpkh.rawValue) whenever(paykitSdkService.paymentRequests()).thenReturn(listOf(record)) - whenever(paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull())).thenReturn(record) + whenever(paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull(), isNull())).thenReturn(record) val repo = paymentProofRepo() repo.prepare(request, MethodId.P2wpkh.rawValue, "bitkit", PaykitPaymentProofKind.Onchain).getOrThrow() @@ -1120,6 +1151,7 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { paymentEndpointIdentifier = eq(MethodId.P2wpkh.rawValue), proofJson = proofCaptor.capture(), billingPeriod = isNull(), + conversionQuoteId = isNull(), ) assertTrue(proofCaptor.firstValue.contains(txid)) } @@ -1282,11 +1314,11 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { paymentRequestRecord(paymentRequestId = secondPaymentRequestId), ), ) - whenever(paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull())) + whenever(paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull(), isNull())) .thenReturn(paymentRequestRecord()) val repo = paymentProofRepo() repo.prepare(firstRequest, MethodId.P2wpkh.rawValue, "bitkit", PaykitPaymentProofKind.Onchain).getOrThrow() - repo.markOnchainPaymentStarted(firstRequest, ONCHAIN_ADDRESS).getOrThrow() + repo.markOnchainPaymentStarted(firstRequest, ONCHAIN_ADDRESS, firstRequest.amount.atomic).getOrThrow() repo.prepare(secondRequest, MethodId.P2wpkh.rawValue, "bitkit", PaykitPaymentProofKind.Onchain).getOrThrow() repo.markOnchainPaymentStarted(secondRequest, ONCHAIN_ADDRESS).getOrThrow() whenever(lightningRepo.currentOnchainSendAttempt()).thenReturn(acceptedAttempt(firstRequest, "ab".repeat(32))) @@ -1308,12 +1340,12 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { val repo = paymentProofRepo() repo.prepare(request, MethodId.P2wpkh.rawValue, "bitkit", PaykitPaymentProofKind.Onchain).getOrThrow() - repo.markOnchainPaymentStarted(request, ONCHAIN_ADDRESS).getOrThrow() + repo.markOnchainPaymentStarted(request, ONCHAIN_ADDRESS, request.amount.atomic).getOrThrow() repo.reconcile() assertTrue(storedProofs.single().onchainMatchingTransactionIdsBeforeAttempt.isEmpty()) assertNull(storedProofs.single().proofData) - verify(paykitSdkService, never()).submitPaymentProof(any(), any(), any(), any(), any(), any()) + verify(paykitSdkService, never()).submitPaymentProof(any(), any(), any(), any(), any(), any(), isNull()) } @Test @@ -2306,8 +2338,8 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { ) = PaykitPaymentRequest( paymentRequestId = paymentRequestId, counterparty = COUNTERPARTY, - amountValue = "0.00001", - amountSats = 1_000uL, + paymentReference = "test-reference", + amount = PaykitAmount(PaykitAsset.BTC, 1_000uL), expiresAt = null, acceptedPaymentEndpointIdentifiers = listOf(endpoint), billingPeriod = billingPeriod, diff --git a/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoSubscriptionTest.kt b/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoSubscriptionTest.kt index 119d9acf6f..83d6625da4 100644 --- a/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoSubscriptionTest.kt +++ b/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoSubscriptionTest.kt @@ -3,12 +3,14 @@ package to.bitkit.repositories import com.synonym.paykit.BillingPeriod +import com.synonym.paykit.ConversionRate import com.synonym.paykit.IdentityStatus import com.synonym.paykit.LinkedPeerRecord import com.synonym.paykit.LinkedPeerState import com.synonym.paykit.OutboundPrivateMessageStatus import com.synonym.paykit.OutboundPrivateSendReport import com.synonym.paykit.PaykitStateObservation +import com.synonym.paykit.PaymentConversion import com.synonym.paykit.PaymentDeadline import com.synonym.paykit.PaymentProofRecord import com.synonym.paykit.PaymentReference @@ -47,6 +49,9 @@ import org.mockito.kotlin.verifyBlocking import org.mockito.kotlin.whenever import to.bitkit.data.SettingsData import to.bitkit.data.SettingsStore +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset +import to.bitkit.models.PaykitRequestPricing import to.bitkit.services.PaykitPaymentRequestProposalTerms import to.bitkit.services.PaykitSdkService import to.bitkit.test.BaseUnitTest @@ -83,6 +88,7 @@ class PaykitPaymentRequestRepoSubscriptionTest : BaseUnitTest(StandardTestDispat private val diagnostics = mock() private val paymentProofStore = mock() private val paymentProofRepo = mock() + private val usdtPayments = mock() private val notificationScheduler = mock() private var schedulerOriginMillis = 0L private val clock = object : Clock { @@ -125,6 +131,9 @@ class PaykitPaymentRequestRepoSubscriptionTest : BaseUnitTest(StandardTestDispat whenever(paymentProofStore.backupStateVersion).thenReturn(MutableStateFlow(0L)) whenever(paymentProofRepo.protectedRequestIdsForSubscriptionCancellation(any(), any())) .thenReturn(Result.success(emptySet())) + whenever(usdtPayments.verifiedReceipts(any())).thenReturn(Result.success(emptyList())) + whenever(usdtPayments.protectedRequestIdsForSubscriptionCancellation(any(), any())) + .thenReturn(Result.success(emptySet())) sut = PaykitPaymentRequestRepo( testDispatcher, paykitSdkService, @@ -133,9 +142,12 @@ class PaykitPaymentRequestRepoSubscriptionTest : BaseUnitTest(StandardTestDispat diagnostics, paymentProofStore, paymentProofRepo, + usdtPayments, notificationScheduler, clock, subscriptionClock, + mock { on { canReceive() }.thenReturn(true) }, + mock { on { currencyState }.thenReturn(kotlinx.coroutines.flow.MutableStateFlow(CurrencyState())) }, ) sut.activate(LOCAL_IDENTITY) } @@ -167,6 +179,71 @@ class PaykitPaymentRequestRepoSubscriptionTest : BaseUnitTest(StandardTestDispat sut.clear() } + @Test + fun `dollar subscription requires usdt receiving and fixes parity for future payments`() = test { + val target = PaykitPaymentRequestTarget(COUNTERPARTY) + whenever( + paykitSdkService.identityStatus() + ).thenReturn(IdentityStatus(LOCAL_IDENTITY, PubkyIdentityCapability.PRIVATE_LINK_CAPABLE)) + whenever(paykitSdkService.linkedPeers()).thenReturn( + listOf(linkedPeer(COUNTERPARTY, LinkedPeerState.LINKED)), + ) + whenever(paykitSdkService.canReceivePaymentRequests(COUNTERPARTY)).thenReturn(true) + val captured = argumentCaptor() + whenever(paykitSdkService.proposePaymentRequest(any(), captured.capture(), eq(LOCAL_IDENTITY))) + .thenReturn(paymentRequestRecord(role = PaymentRequestLocalRole.PAYEE)) + for (enabled in listOf(false, true)) { + val settings = SettingsData(sharesPrivatePaykitEndpoints = true, publicPaykitUsdtEnabled = enabled) + whenever(settingsStore.data).thenReturn(flowOf(settings)) + val result = sut.proposeSubscription( + PaykitSubscriptionDraft( + amount = PaykitAmount(PaykitAsset.USD, 500uL), + name = "Monthly support", + description = "", + frequency = PaykitRecurrenceUnit.Month, + expiresAt = clock.now() + 60.seconds, + ), + target, + listOf(COUNTERPARTY), + ) + if (!PublicPaykitRepo.isUsdtPaymentOptionEnabled(settings)) { + assertEquals(PaykitPaymentRequestError.RequestUnavailable, result.exceptionOrNull()) + assertTrue(captured.allValues.isEmpty()) + continue + } + result.getOrThrow() + val terms = captured.lastValue + assertEquals(listOf(MethodId.UsdtArbitrum.rawValue), terms.acceptedPaymentEndpointIdentifiers) + assertEquals(PaymentConversion.Fixed(listOf(ConversionRate("usdt", "1"))), terms.conversion) + val later = clock.now() + (40 * 86400).seconds + val period = PaykitBillingPeriod(later, later + (30 * 86400).seconds) + val pricing = PaykitRequestPricing(terms.conversion, terms.paymentDeadline) + val payment = pricing.payment( + PaykitAmount.parse(PaykitAsset.USD, terms.amountValue), + PaykitAsset.USDT, + period, + later, + ) + assertEquals("5", payment.amount.value) + assertEquals(null, payment.quoteId) + assertTrue(payment.isValid(later)) + assertTrue(pricing.quotes.isEmpty()) + } + } + + @Test + fun `refresh preserves all supported subscription denominations`() = test { + val records = PaykitAsset.entries.map { asset -> + val record = paymentRequestRecord(id = asset.code, state = PaymentRequestLifecycleState.ACTIVE_RECURRING) + record.copy(terms = requireNotNull(record.terms).copy(amount = PaymentRequestAmount("1", asset.code))) + } + whenever(paykitSdkService.allPaymentRequests(anyOrNull())).thenReturn(records) + sut.refresh().getOrThrow() + assertEquals(PaykitAsset.entries.toSet(), sut.subscriptions.value.map { it.amount.asset }.toSet()) + assertEquals(PaykitAsset.entries.toSet(), sut.pendingRequests.value.map { it.amount.asset }.toSet()) + assertTrue(sut.pendingRequests.value.all { it.amount.value == "1" }) + } + @Test fun `inbox refresh maps active subscription and exposes current unpaid period`() = test { val metadataText = """ @@ -360,6 +437,7 @@ class PaykitPaymentRequestRepoSubscriptionTest : BaseUnitTest(StandardTestDispat assertEquals(PaykitPaymentProofKind.Lightning, received.paymentProofKind) } + @Suppress("LongMethod") @Test fun `creator proposal sends recurring terms and stays queued until delivery`() = test { val target = stubSubscriptionProposal() @@ -373,7 +451,7 @@ class PaykitPaymentRequestRepoSubscriptionTest : BaseUnitTest(StandardTestDispat val proposal = async { sut.proposeSubscription( draft = PaykitSubscriptionDraft( - amountSats = 100_000uL, + amount = PaykitAmount(PaykitAsset.BTC, 100_000uL), name = " Monthly support ", description = " Thank you ", frequency = PaykitRecurrenceUnit.Month, @@ -401,6 +479,9 @@ class PaykitPaymentRequestRepoSubscriptionTest : BaseUnitTest(StandardTestDispat } with(captured.firstValue) { assertEquals("0.001", amountValue) + assertFalse(MethodId.UsdtArbitrum.rawValue in acceptedPaymentEndpointIdentifiers) + assertTrue(acceptedPaymentEndpointIdentifiers.isNotEmpty()) + assertEquals(null, conversion) assertEquals(expiresAt.toString(), proposalExpiresAt) assertEquals(1u, recurrence?.every) assertEquals("month", recurrence?.unit) @@ -426,7 +507,7 @@ class PaykitPaymentRequestRepoSubscriptionTest : BaseUnitTest(StandardTestDispat val creation = sut.proposeSubscription( draft = PaykitSubscriptionDraft( - amountSats = 100_000uL, + amount = PaykitAmount(PaykitAsset.BTC, 100_000uL), name = "Monthly support", description = "Thank you", frequency = PaykitRecurrenceUnit.Month, @@ -449,7 +530,7 @@ class PaykitPaymentRequestRepoSubscriptionTest : BaseUnitTest(StandardTestDispat sut.proposeSubscription( draft = PaykitSubscriptionDraft( - amountSats = 100_000uL, + amount = PaykitAmount(PaykitAsset.BTC, 100_000uL), name = "Monthly support", description = "Thank you", frequency = PaykitRecurrenceUnit.Month, @@ -482,7 +563,7 @@ class PaykitPaymentRequestRepoSubscriptionTest : BaseUnitTest(StandardTestDispat listOf(null, byteArrayOf(0, 1, 2)).forEach { icon -> val result = sut.proposeSubscription( draft = PaykitSubscriptionDraft( - amountSats = 1000uL, + amount = PaykitAmount(PaykitAsset.BTC, 1000uL), name = "Support", description = "💜".repeat(256), frequency = PaykitRecurrenceUnit.Month, @@ -1070,7 +1151,7 @@ class PaykitPaymentRequestRepoSubscriptionTest : BaseUnitTest(StandardTestDispat } @Test - fun `deadline subscriptions retain paid periods and cancellation without offering payments`() = test { + fun `recurring payment deadlines retain paid history and bound unpaid amounts`() = test { advanceTimeBy(32 * 24 * 60 * 60 * 1000L) val proof = mock { on { billingPeriod } doReturn BillingPeriod("2027-01-01T08:00:00Z", "2027-02-01T08:00:00Z") @@ -1090,12 +1171,11 @@ class PaykitPaymentRequestRepoSubscriptionTest : BaseUnitTest(StandardTestDispat sut.refresh().getOrThrow() - assertTrue(sut.pendingRequests.value.isEmpty()) + assertTrue(sut.pendingRequests.value.all { !it.payment(PaykitAsset.BTC, clock.now()).isValid(clock.now()) }) assertEquals(2, sut.subscriptions.value.size) sut.subscriptions.value.forEach { subscription -> assertEquals(1, subscription.paidPeriods.size) assertTrue(subscription.canCancel(clock.now())) - assertEquals(null, subscription.paymentDueOnAcceptance(clock.now())) } val paid = sut.paymentRequestHistory.value.single() assertEquals(PaymentRequestLifecycleState.PROOF_SUBMITTED, paid.lifecycleState) @@ -1202,6 +1282,48 @@ class PaykitPaymentRequestRepoSubscriptionTest : BaseUnitTest(StandardTestDispat verifyBlocking(paykitSdkService, never()) { cancelPaymentRequest(any(), any(), anyOrNull()) } } + @Test + fun `subscription cannot be canceled while USDT execution is unresolved`() = test { + val requestId = PaykitPaymentRequestId(PAYMENT_REQUEST_ID, COUNTERPARTY, "2027-01-01T08:00:00Z") + whenever(usdtPayments.protectedRequestIdsForSubscriptionCancellation(eq(LOCAL_IDENTITY), any())) + .thenReturn(Result.success(setOf(requestId))) + whenever(paykitSdkService.allPaymentRequests(anyOrNull())).thenReturn( + listOf(paymentRequestRecord(state = PaymentRequestLifecycleState.ACTIVE_RECURRING)) + ) + sut.refresh().getOrThrow() + + val result = sut.cancel(sut.subscriptions.value.single()) + + assertTrue(result.exceptionOrNull() is PaykitPaymentRequestError.OperationInProgress) + verifyBlocking(paykitSdkService, never()) { cancelPaymentRequest(any(), any(), anyOrNull()) } + } + + @Test + fun `an in-flight cancellation prevents authorizing a newly started payment`() = test { + val active = paymentRequestRecord(state = PaymentRequestLifecycleState.ACTIVE_RECURRING) + val canceled = active.copy(state = PaymentRequestLifecycleState.CANCELED) + whenever(paykitSdkService.allPaymentRequests(anyOrNull())).thenReturn(listOf(active)) + sut.refresh().getOrThrow() + val request = sut.pendingRequests.value.single() + sut.ensurePaymentAllowed(request).getOrThrow() + val started = CompletableDeferred() + val finish = CompletableDeferred() + whenever(paykitSdkService.cancelPaymentRequest(COUNTERPARTY, PAYMENT_REQUEST_ID)).doSuspendableAnswer { + started.complete(Unit) + finish.await() + canceled + } + val cancellation = async { sut.cancel(sut.subscriptions.value.single()) } + started.await() + + assertTrue(sut.ensurePaymentAllowed(request).isFailure) + + whenever(paykitSdkService.allPaymentRequests(anyOrNull())).thenReturn(listOf(canceled)) + finish.complete(Unit) + cancellation.await().getOrThrow() + assertTrue(sut.ensurePaymentAllowed(request).isFailure) + } + @Test fun `subscription cancellation proceeds without a started payment`() = test { val active = paymentRequestRecord( @@ -1242,12 +1364,15 @@ class PaykitPaymentRequestRepoSubscriptionTest : BaseUnitTest(StandardTestDispat val subscriptions = sut.subscriptions.value assertEquals(setOf("deadline", "unsupported"), subscriptions.map { it.paymentRequestId }.toSet()) - assertTrue(subscriptions.none { it.isProposalActionable(clock.now()) }) + assertEquals( + listOf("deadline"), + subscriptions.filter { + it.isProposalActionable(clock.now()) + }.map { it.paymentRequestId } + ) assertEquals(subscriptions, sut.subscriptionProposals()) val deadlineSubscription = subscriptions.first { it.paymentRequestId == "deadline" } - assertEquals(null, deadlineSubscription.paymentDueOnAcceptance(clock.now())) - assertTrue(sut.accept(deadlineSubscription).exceptionOrNull() is PaykitPaymentRequestError.RequestUnavailable) - verifyBlocking(paykitSdkService, never()) { acceptPaymentRequest(any(), any(), any()) } + assertTrue(deadlineSubscription.paymentDueOnAcceptance(clock.now()) != null) } @Test diff --git a/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoTest.kt b/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoTest.kt index b0b703fa6a..b36e98f512 100644 --- a/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoTest.kt +++ b/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoTest.kt @@ -29,6 +29,7 @@ import com.synonym.paykit.PrivateJsonObject import com.synonym.paykit.PrivateOperationError import com.synonym.paykit.PrivateStreamCounterpartyIntakeReport import com.synonym.paykit.PubkyIdentityCapability +import kotlinx.collections.immutable.persistentListOf import kotlinx.coroutines.CancellationException import kotlinx.coroutines.CompletableDeferred import kotlinx.coroutines.ExperimentalCoroutinesApi @@ -61,6 +62,9 @@ import org.mockito.kotlin.verifyBlocking import org.mockito.kotlin.whenever import to.bitkit.data.SettingsData import to.bitkit.data.SettingsStore +import to.bitkit.models.FxRate +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset import to.bitkit.models.PubkyPublicKeyFormat import to.bitkit.models.safe import to.bitkit.services.PaykitPaymentRequestProposalTerms @@ -236,12 +240,14 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) { private val paykitSdkService = mock() private val settingsStore = mock() + private val lightningRepo = mock() private val presentationStore = mock() private val diagnostics = mock() private val paymentProofStore = mock() private val proofStateVersion = MutableStateFlow(0L) private val paymentSubmissionActive = MutableStateFlow(false) private val paymentProofRepo = mock() + private val usdtPayments = mock() private val subscriptionNotificationScheduler = mock() private var schedulerOriginMillis = 0L private val clock = object : Clock { @@ -259,6 +265,46 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) { paymentSubmissionActive.value = it.getArgument(0) Unit } + stubMessageProcessing() + whenever(settingsStore.isPaykitEnabled).thenReturn(flowOf(true)) + whenever(settingsStore.data).thenReturn(flowOf(SettingsData(sharesPrivatePaykitEndpoints = true))) + whenever(presentationStore.load(LOCAL_IDENTITY)).thenReturn(emptySet()) + whenever(presentationStore.loadAcceptedOneTimeIds(any())).thenReturn(emptySet()) + whenever(presentationStore.addAcceptedOneTimeId(any(), any())).thenAnswer { + setOf(it.getArgument(1)) + } + whenever(presentationStore.removeAcceptedOneTimeIds(any(), any())).thenReturn(emptySet()) + whenever(lightningRepo.canReceive()).thenReturn(true) + whenever( + presentationStore.loadSubscriptionState(any()) + ).thenReturn(PaykitSubscriptionPresentationState()) + whenever(paymentProofStore.completedRequestProofKindsAwaitingSubmission(LOCAL_IDENTITY)).thenReturn(emptyMap()) + whenever(paymentProofStore.inFlightRequestIds(LOCAL_IDENTITY)).thenReturn(emptySet()) + whenever(paymentProofStore.backupStateVersion).thenReturn(proofStateVersion) + whenever(paymentProofRepo.protectedRequestIdsForSubscriptionCancellation(any(), any())) + .thenReturn(Result.success(emptySet())) + whenever(usdtPayments.verifiedReceipts(any())).thenReturn(Result.success(emptyList())) + whenever(usdtPayments.protectedRequestIdsForSubscriptionCancellation(any(), any())) + .thenReturn(Result.success(emptySet())) + sut = PaykitPaymentRequestRepo( + testDispatcher, + paykitSdkService, + settingsStore, + presentationStore, + diagnostics, + paymentProofStore, + paymentProofRepo, + usdtPayments, + subscriptionNotificationScheduler, + clock, + clock, + lightningRepo, + currencyRepoWithRate(), + ) + sut.activate(LOCAL_IDENTITY) + } + + private suspend fun stubMessageProcessing() { whenever(paykitSdkService.processPendingPrivateMessages()).thenReturn(emptyList()) whenever(paykitSdkService.processOutboundPrivateMessages(any())).thenReturn( OutboundPrivateSendReport(emptyList(), emptyList(), emptyList(), emptyList(), emptyList()), @@ -328,6 +374,29 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) { } } + private fun currencyRepoWithRate(): CurrencyRepo = + mock { + on { currencyState }.thenReturn( + MutableStateFlow( + CurrencyState( + rates = persistentListOf( + FxRate( + symbol = "BTCUSD", + lastPrice = "100000", + base = "BTC", + baseName = "Bitcoin", + quote = "USD", + quoteName = "US Dollar", + currencySymbol = "$", + currencyFlag = "", + lastUpdatedAt = clock.now().toEpochMilliseconds(), + ), + ), + ), + ), + ) + } + @After fun tearDown() = test { sut.clear() @@ -852,7 +921,7 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) { sut.refresh().getOrThrow() val request = sut.pendingRequests.value.single() - assertEquals(100_000uL, request.amountSats) + assertEquals(100_000uL, request.amount.atomic) assertEquals(listOf(MethodId.Bolt11.rawValue), request.acceptedPaymentEndpointIdentifiers) } @@ -1003,7 +1072,7 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) { sut.refresh().getOrThrow() assertEquals(listOf("millisatoshi-safe-max"), sut.pendingRequests.value.map { it.paymentRequestId }) - assertEquals(listOf(ULong.MAX_VALUE / 1000uL), sut.pendingRequests.value.map { it.amountSats }) + assertEquals(listOf(ULong.MAX_VALUE / 1000uL), sut.pendingRequests.value.map { it.amount.atomic }) } @Test @@ -1011,8 +1080,8 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) { val request = PaykitPaymentRequest( paymentRequestId = PAYMENT_REQUEST_ID, counterparty = COUNTERPARTY, - amountValue = "0.000025", - amountSats = 2_500uL, + paymentReference = "test-reference", + amount = PaykitAmount(PaykitAsset.BTC, 2_500uL), expiresAt = null, acceptedPaymentEndpointIdentifiers = listOf(MethodId.Bolt11.rawValue), ) @@ -1070,7 +1139,7 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) { sut.refresh().getOrThrow() - assertEquals(listOf("incoming"), sut.pendingRequests.value.map { it.paymentRequestId }) + assertEquals(listOf("incoming", "deadline-PROPOSED"), sut.pendingRequests.value.map { it.paymentRequestId }) assertEquals( setOf( "incoming", "accepted", "rejected", "expired", "outgoing", "unsupported", @@ -1605,9 +1674,12 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) { diagnostics, paymentProofStore, paymentProofRepo, + usdtPayments, subscriptionNotificationScheduler, clock, clock, + lightningRepo, + mock(), ) other.activate(LOCAL_IDENTITY) var record = paymentRequestRecord() @@ -1783,55 +1855,51 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) { } @Test - fun `proposal uses exact linked capable path and canonical bitcoin terms`() = test { - val target = PaykitPaymentRequestTarget(COUNTERPARTY) - whenever( - paykitSdkService.identityStatus() - ).thenReturn(IdentityStatus(LOCAL_IDENTITY, PubkyIdentityCapability.PRIVATE_LINK_CAPABLE)) - whenever(paykitSdkService.linkedPeers()).thenReturn( - listOf(linkedPeer(COUNTERPARTY, LinkedPeerState.LINKED)), - ) - whenever(paykitSdkService.canReceivePaymentRequests(eq(COUNTERPARTY), any())).thenReturn( - true, - ) - whenever( - paykitSdkService.proposePaymentRequest( - eq(COUNTERPARTY), - any(), - eq(LOCAL_IDENTITY), - ), - ).thenReturn( - paymentRequestRecord( - role = PaymentRequestLocalRole.PAYEE, - counterparty = COUNTERPARTY, - ), - ) + fun `proposal uses canonical terms and accepts available selected methods`() = test { + val target = + stubProposal(paymentRequestRecord(role = PaymentRequestLocalRole.PAYEE, counterparty = COUNTERPARTY)) val expiry = clock.now().plus(60.seconds) - val creation = sut.propose( - draft = PaykitPaymentRequestDraft(amountSats = 1uL, note = " Lunch ", expiresAt = expiry), - target = target, - savedPublicKeys = listOf(COUNTERPARTY), - ).getOrThrow() - val request = creation.request - - val proposal = argumentCaptor() - verifyBlocking(paykitSdkService) { - proposePaymentRequest( - eq(COUNTERPARTY), - proposal.capture(), - eq(LOCAL_IDENTITY), - ) + val onchain = MethodId.entries.first { it.isOnchain }.rawValue + for ((canReceiveLightning, restriction) in listOf(false to null, true to null, true to listOf(onchain))) { + whenever(lightningRepo.canReceive()).thenReturn(canReceiveLightning) + clearInvocations(paykitSdkService) + val creation = sut.propose( + draft = PaykitPaymentRequestDraft( + amount = PaykitAmount(PaykitAsset.BTC, 1uL), + note = " Lunch ", + expiresAt = expiry, + acceptedPaymentEndpointIdentifiers = restriction, + ), + target = target, + savedPublicKeys = listOf(COUNTERPARTY), + ).getOrThrow() + val request = creation.request + + val proposal = argumentCaptor() + verifyBlocking(paykitSdkService) { + proposePaymentRequest(eq(COUNTERPARTY), proposal.capture(), eq(LOCAL_IDENTITY)) + } + assertEquals("0.00000001", proposal.firstValue.amountValue) + assertTrue(proposal.firstValue.paymentReference.startsWith("bitkit-")) + assertEquals(expiry.toString(), proposal.firstValue.proposalExpiresAt) + val accepted = proposal.firstValue.acceptedPaymentEndpointIdentifiers + if (restriction != null) { + assertEquals(restriction, accepted) + } else { + assertTrue(accepted.contains(onchain)) + assertEquals(canReceiveLightning, accepted.contains(MethodId.Bolt11.rawValue)) + assertEquals( + PublicPaykitRepo.isUsdtPaymentOptionEnabled(SettingsData()), + accepted.contains(MethodId.UsdtArbitrum.rawValue), + ) + } + assertEquals("{\"note\":\"Lunch\"}", proposal.firstValue.metadataJson) + assertEquals("Lunch", request.note) + assertEquals(PaykitPaymentRequestDeliveryStatus.Queued, request.deliveryStatus) + assertEquals(LOCAL_IDENTITY, creation.creatorIdentity) + assertTrue(creation.wasPublishedToActiveState) } - assertEquals("0.00000001", proposal.firstValue.amountValue) - assertTrue(proposal.firstValue.paymentReference.startsWith("bitkit-")) - assertEquals(expiry.toString(), proposal.firstValue.proposalExpiresAt) - assertTrue(proposal.firstValue.acceptedPaymentEndpointIdentifiers.isNotEmpty()) - assertEquals("{\"note\":\"Lunch\"}", proposal.firstValue.metadataJson) - assertEquals("Lunch", request.note) - assertEquals(PaykitPaymentRequestDeliveryStatus.Queued, request.deliveryStatus) - assertEquals(LOCAL_IDENTITY, creation.creatorIdentity) - assertTrue(creation.wasPublishedToActiveState) verify(paykitSdkService).identityStatus(Priority.Interactive) verify(paykitSdkService).linkedPeers(Priority.Interactive) verify(paykitSdkService).processOutboundPrivateMessages(COUNTERPARTY, Priority.Interactive) @@ -1855,7 +1923,7 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) { whenever(paykitSdkService.allPaymentRequests(LOCAL_IDENTITY)).thenReturn(listOfNotNull(freshRecord)) val creation = sut.propose( - PaykitPaymentRequestDraft(1uL, "Lunch", clock.now().plus(60.seconds)), + PaykitPaymentRequestDraft(PaykitAmount(PaykitAsset.BTC, 1uL), "Lunch", clock.now().plus(60.seconds)), target, listOf(COUNTERPARTY), ).getOrThrow() @@ -1892,7 +1960,7 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) { clearInvocations(paykitSdkService) val creation = sut.propose( - PaykitPaymentRequestDraft(1uL, "Lunch", clock.now().plus(60.seconds)), + PaykitPaymentRequestDraft(PaykitAmount(PaykitAsset.BTC, 1uL), "Lunch", clock.now().plus(60.seconds)), target, listOf(COUNTERPARTY), ).getOrThrow() @@ -1911,7 +1979,7 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) { fun `proposal remains created after status read failure and propagates status read cancellation`() = test { val record = paymentRequestRecord(role = PaymentRequestLocalRole.PAYEE).copy(proposalOutboundMessageId = 7uL) val target = stubProposal(record) - val draft = PaykitPaymentRequestDraft(1uL, "Lunch", clock.now().plus(60.seconds)) + val draft = PaykitPaymentRequestDraft(PaykitAmount(PaykitAsset.BTC, 1uL), "Lunch", clock.now().plus(60.seconds)) var cancelled = false whenever(paykitSdkService.allPaymentRequests(LOCAL_IDENTITY)).doSuspendableAnswer { if (cancelled) throw CancellationException() @@ -1938,7 +2006,7 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) { ) val creation = sut.propose( - PaykitPaymentRequestDraft(1uL, "Lunch", clock.now().plus(60.seconds)), + PaykitPaymentRequestDraft(PaykitAmount(PaykitAsset.BTC, 1uL), "Lunch", clock.now().plus(60.seconds)), target, listOf(COUNTERPARTY), ).getOrThrow() @@ -1949,7 +2017,10 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) { @Test fun `proposal revalidates and drains only the selected saved contact`() = test { - val target = PaykitPaymentRequestTarget(COUNTERPARTY) + val target = + stubProposal( + paymentRequestRecord(role = PaymentRequestLocalRole.PAYEE).copy(proposalOutboundMessageId = 7uL) + ) val stalledDiscovery = CompletableDeferred() val unrelatedDelivery = CompletableDeferred() whenever(paykitSdkService.processPendingPrivateMessages()).doSuspendableAnswer { @@ -1963,32 +2034,23 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) { whenever(paykitSdkService.processOutboundPrivateMessages(COUNTERPARTY)).thenReturn( OutboundPrivateSendReport(listOf(7uL), listOf(7uL), emptyList(), emptyList(), emptyList()), ) - whenever( - paykitSdkService.identityStatus() - ).thenReturn(IdentityStatus(LOCAL_IDENTITY, PubkyIdentityCapability.PRIVATE_LINK_CAPABLE)) whenever(paykitSdkService.linkedPeers()).thenReturn( listOf( linkedPeer(COUNTERPARTY, LinkedPeerState.LINKED), linkedPeer(SECOND_IDENTITY, LinkedPeerState.LINKED), ), ) - whenever(paykitSdkService.canReceivePaymentRequests(eq(COUNTERPARTY), any())).thenReturn( - true, - ) whenever(paykitSdkService.canReceivePaymentRequests(eq(SECOND_IDENTITY), any())).doSuspendableAnswer { stalledDiscovery.await() true } - whenever(paykitSdkService.proposePaymentRequest(any(), any(), eq(LOCAL_IDENTITY))).thenReturn( - paymentRequestRecord( - role = PaymentRequestLocalRole.PAYEE, - counterparty = COUNTERPARTY, - ).copy(proposalOutboundMessageId = 7uL), - ) - val proposal = async { sut.propose( - draft = PaykitPaymentRequestDraft(1uL, "Lunch", clock.now().plus(60.seconds)), + draft = PaykitPaymentRequestDraft( + PaykitAmount(PaykitAsset.BTC, 1uL), + "Lunch", + clock.now().plus(60.seconds) + ), target = target, savedPublicKeys = listOf(SECOND_IDENTITY, COUNTERPARTY), ) @@ -2031,7 +2093,11 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) { val proposal = async { sut.propose( - draft = PaykitPaymentRequestDraft(1uL, "Lunch", clock.now().plus(60.seconds)), + draft = PaykitPaymentRequestDraft( + PaykitAmount(PaykitAsset.BTC, 1uL), + "Lunch", + clock.now().plus(60.seconds) + ), target = target, savedPublicKeys = listOf(COUNTERPARTY), ).getOrThrow() @@ -2560,7 +2626,7 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) { assertFailsWith { sut.propose( - draft = PaykitPaymentRequestDraft(1uL, "", clock.now()), + draft = PaykitPaymentRequestDraft(PaykitAmount(PaykitAsset.BTC, 1uL), "", clock.now()), target = target, savedPublicKeys = listOf(COUNTERPARTY), ).getOrThrow() diff --git a/app/src/test/java/to/bitkit/repositories/PaykitSubscriptionNotificationSchedulerTest.kt b/app/src/test/java/to/bitkit/repositories/PaykitSubscriptionNotificationSchedulerTest.kt index 572f7d7d08..9ea0a9c24e 100644 --- a/app/src/test/java/to/bitkit/repositories/PaykitSubscriptionNotificationSchedulerTest.kt +++ b/app/src/test/java/to/bitkit/repositories/PaykitSubscriptionNotificationSchedulerTest.kt @@ -21,11 +21,13 @@ import org.mockito.kotlin.atLeast import org.mockito.kotlin.clearInvocations import org.mockito.kotlin.eq import org.mockito.kotlin.mock -import org.mockito.kotlin.never import org.mockito.kotlin.verify import org.mockito.kotlin.whenever import org.robolectric.RobolectricTestRunner import org.robolectric.annotation.Config +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset +import to.bitkit.models.PaykitRequestPricing import to.bitkit.ui.EXTRA_PAYKIT_BILLING_PERIOD_STARTS_AT import to.bitkit.ui.EXTRA_PAYKIT_COUNTERPARTY import to.bitkit.ui.EXTRA_PAYKIT_PAYER_IDENTITY @@ -282,19 +284,6 @@ class PaykitSubscriptionNotificationSchedulerTest { verify(workClient).cancelUniqueWork(WORK_NAME) } - @Test - fun `deadline subscriptions do not schedule payment reminders`() { - sut.synchronize( - subscriptions = listOf(subscription().copy(hasPaymentDeadline = true)), - acceptedAt = { NOW }, - pendingRequestIds = emptySet(), - payerIdentity = PAYER_IDENTITY, - notificationsEnabled = true, - ) - - verify(workClient, never()).enqueueUniqueWork(any(), any(), any()) - } - @Test fun `disabling and canceling clear tagged work`() { sut.synchronize( @@ -322,8 +311,9 @@ class PaykitSubscriptionNotificationSchedulerTest { private fun subscription() = PaykitSubscription( paymentRequestId = PAYMENT_REQUEST_ID, counterparty = COUNTERPARTY, - amountValue = "0.00025", - amountSats = 25_000uL, + amount = PaykitAmount(PaykitAsset.BTC, 25_000uL), + paymentReference = "fixture-reference", + pricing = PaykitRequestPricing(), note = "Weekly coffee", createdAt = NOW, proposalExpiresAt = null, diff --git a/app/src/test/java/to/bitkit/repositories/PaykitSubscriptionProposalTest.kt b/app/src/test/java/to/bitkit/repositories/PaykitSubscriptionProposalTest.kt index 437899bea1..a8baf8b9c9 100644 --- a/app/src/test/java/to/bitkit/repositories/PaykitSubscriptionProposalTest.kt +++ b/app/src/test/java/to/bitkit/repositories/PaykitSubscriptionProposalTest.kt @@ -45,6 +45,7 @@ class PaykitSubscriptionProposalTest { private fun terms(description: String, iconUri: String? = null) = PaykitPaymentRequestProposalTerms( amountValue = "0.001", + amountAsset = "btc", paymentReference = "bitkit-00000000-0000-0000-0000-000000000000", proposalExpiresAt = "2027-01-22T08:00:00.000Z", recurrence = PaykitPaymentRequestRecurrenceTerms( diff --git a/app/src/test/java/to/bitkit/repositories/PaykitSubscriptionTest.kt b/app/src/test/java/to/bitkit/repositories/PaykitSubscriptionTest.kt index 7751a3f744..b764a92671 100644 --- a/app/src/test/java/to/bitkit/repositories/PaykitSubscriptionTest.kt +++ b/app/src/test/java/to/bitkit/repositories/PaykitSubscriptionTest.kt @@ -4,6 +4,9 @@ package to.bitkit.repositories import com.synonym.paykit.PaymentRequestLifecycleState import org.junit.Test +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset +import to.bitkit.models.PaykitRequestPricing import java.util.TimeZone import kotlin.test.assertEquals import kotlin.test.assertFalse @@ -179,8 +182,9 @@ class PaykitSubscriptionTest { val subscription = PaykitSubscription( paymentRequestId = "shared", counterparty = "counterparty-a", - amountValue = "0.001", - amountSats = 100_000uL, + amount = PaykitAmount(PaykitAsset.BTC, 100_000uL), + paymentReference = "fixture-reference", + pricing = PaykitRequestPricing(), note = null, createdAt = null, proposalExpiresAt = null, diff --git a/app/src/test/java/to/bitkit/repositories/PaykitUsdtPaymentRepoTest.kt b/app/src/test/java/to/bitkit/repositories/PaykitUsdtPaymentRepoTest.kt new file mode 100644 index 0000000000..c500ef16ac --- /dev/null +++ b/app/src/test/java/to/bitkit/repositories/PaykitUsdtPaymentRepoTest.kt @@ -0,0 +1,603 @@ +@file:OptIn(kotlin.time.ExperimentalTime::class) + +package to.bitkit.repositories + +import com.synonym.bitkitcore.UsdtDestination +import com.synonym.bitkitcore.UsdtException +import com.synonym.bitkitcore.UsdtPaymentProof +import com.synonym.bitkitcore.UsdtPaymentProofBinding +import com.synonym.bitkitcore.UsdtPaymentRequest +import com.synonym.bitkitcore.UsdtQuote +import com.synonym.bitkitcore.UsdtTransfer +import com.synonym.bitkitcore.UsdtTransferStatus +import com.synonym.bitkitcore.UsdtVerifiedPayment +import com.synonym.bitkitcore.UsdtWallet +import com.synonym.bitkitcore.usdtParsePaymentRequest +import com.synonym.paykit.BillingPeriod +import com.synonym.paykit.ConversionRate +import com.synonym.paykit.IdentityStatus +import com.synonym.paykit.PaymentConversion +import com.synonym.paykit.PaymentConversionQuoteRecord +import com.synonym.paykit.PaymentProofRecord +import com.synonym.paykit.PaymentReference +import com.synonym.paykit.PaymentRequestAmount +import com.synonym.paykit.PaymentRequestLifecycleState +import com.synonym.paykit.PaymentRequestLocalRole +import com.synonym.paykit.PaymentRequestRecord +import com.synonym.paykit.PaymentRequestRecurrence +import com.synonym.paykit.PaymentRequestTerms +import com.synonym.paykit.PrivateJsonObject +import com.synonym.paykit.PubkyIdentityCapability +import kotlinx.serialization.encodeToString +import kotlinx.serialization.json.Json +import org.junit.After +import org.junit.Before +import org.junit.Test +import org.mockito.MockedStatic +import org.mockito.Mockito +import org.mockito.kotlin.any +import org.mockito.kotlin.argumentCaptor +import org.mockito.kotlin.doSuspendableAnswer +import org.mockito.kotlin.mock +import org.mockito.kotlin.verify +import org.mockito.kotlin.whenever +import to.bitkit.data.keychain.Keychain +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset +import to.bitkit.models.PaykitRequestPricing +import to.bitkit.models.PaykitUsdt +import to.bitkit.services.PaykitSdkService +import to.bitkit.services.UsdtService +import to.bitkit.test.BaseUnitTest +import to.bitkit.viewmodels.ContactPaymentContext +import kotlin.test.assertEquals +import kotlin.test.assertNotNull +import kotlin.test.assertTrue +import kotlin.time.Clock +import kotlin.time.Instant + +class PaykitUsdtPaymentRepoTest : BaseUnitTest() { + private val identity = "pubky1rsduhcxpw74snwyct86m38c63j3pq8x4ycqikxg64roik8yw5xg" + private val contact = "pubky3rsduhcxpw74snwyct86m38c63j3pq8x4ycqikxg64roik8yw5xg" + private val address = "0x1111111111111111111111111111111111111111" + private val keychain: Keychain = mock() + private val sdk: PaykitSdkService = mock() + private val proofs: PaykitPaymentProofRepo = mock() + private val usdt: UsdtRepo = mock() + private val service: UsdtService = mock() + private val wallet: UsdtWallet = mock() + private val clock = object : Clock { override fun now() = Instant.fromEpochSeconds(1_800_000_000) } + private var stored: String? = null + private lateinit var core: MockedStatic<*> + private val request = PaykitPaymentRequest( + paymentRequestId = "550e8400-e29b-41d4-a716-446655440000", + counterparty = contact, + amount = PaykitAmount(PaykitAsset.USD, 5u), + paymentReference = "payment-reference", + pricing = PaykitRequestPricing(PaymentConversion.Fixed(listOf(ConversionRate("usdt", "1")))), + expiresAt = null, + acceptedPaymentEndpointIdentifiers = listOf(MethodId.UsdtArbitrum.rawValue), + ) + private val quote = UsdtQuote( + id = "quote", + bridgeProvider = null, + recipient = address, + destination = UsdtDestination.ARBITRUM, + amount = 50_000u, + receivedAmount = 50_000u, + maximumFee = 100u, + expiresAt = 1_800_000_100u, + ) + private val amount = PaykitAmount(PaykitAsset.USDT, 50_000u) + + @Before + fun setUp() = test { + core = Mockito.mockStatic(Class.forName("com.synonym.bitkitcore.Bitkitcore_androidKt")) + core.`when` { usdtParsePaymentRequest(address) } + .thenReturn(UsdtPaymentRequest(address, null, null)) + val endpoint = PaykitUsdt.endpoint(address) + whenever(keychain.loadString(any())).thenAnswer { stored } + whenever(keychain.upsertString(any(), any())).doSuspendableAnswer { stored = it.getArgument(1) } + whenever( + sdk.identityStatus() + ).thenReturn(IdentityStatus(identity, PubkyIdentityCapability.PRIVATE_LINK_CAPABLE)) + whenever(sdk.paymentRequests()).thenReturn(emptyList()) + whenever(usdt.paymentEndpoint()).thenReturn(Result.success(endpoint)) + whenever( + service.paymentProof(any(), any()) + ).thenReturn(UsdtPaymentProof("42161", "0x" + "a".repeat(64), "0", "0x" + "b".repeat(130))) + whenever(service.wallet()).thenReturn(wallet) + whenever(usdt.operation(any())).doSuspendableAnswer { + val block = it.getArgument Any?>(0) + runCatching { block(service) } + } + stubStoredTransfer(Result.success(null)) + } + + @After + fun tearDown() { if (::core.isInitialized) core.close() } + + private fun stubStoredTransfer(result: Result) { + result.getOrNull()?.let { whenever(it.id).thenReturn(quote.id) } + org.mockito.kotlin.doAnswer { result.getOrThrow()?.let(::listOf).orEmpty() }.whenever(wallet).history() + } + + private suspend fun stubVerification( + first: Result, + second: Result? = null, + ) { + val results = listOfNotNull(first, second) + var index = 0 + whenever(wallet.verifyPaymentProof(any(), any())).doSuspendableAnswer { + results[(index++).coerceAtMost(results.lastIndex)].getOrThrow() + } + } + + private fun repo() = PaykitUsdtPaymentRepo(testDispatcher, keychain, sdk, proofs, usdt, clock) + private fun context(request: PaykitPaymentRequest = this.request) = + ContactPaymentContext( + contact, + privatePaymentContext = PrivatePaykitPaymentContext( + mapOf(MethodId.UsdtArbitrum.rawValue to "bitkit"), + null + ), + incomingPaymentRequest = request, + endpoints = listOf(PaykitUsdt.endpoint(address)) + ) + + @Test + fun `cancellation protection reads durable started state and scopes wallet and identity`() = test { + val period = PaykitBillingPeriod(clock.now(), clock.now() + kotlin.time.Duration.parse("1d")) + val recurring = request.copy(billingPeriod = period) + val subscription = PaykitSubscriptionId(request.paymentRequestId, contact) + val repo = repo() + repo.prepare(context(recurring), quote, amount, recurring.payment(PaykitAsset.USDT, clock.now())).getOrThrow() + assertTrue(repo.protectedRequestIdsForSubscriptionCancellation(identity, subscription).getOrThrow().isEmpty()) + whenever(usdt.send(quote)).thenReturn(Result.success(mock())) + repo.send(quote) { + assertEquals( + setOf(recurring.id), + repo().protectedRequestIdsForSubscriptionCancellation(identity, subscription).getOrThrow(), + ) + }.getOrThrow() + val restarted = repo() + restarted.prepare( + context(recurring), + quote, + amount, + recurring.payment(PaykitAsset.USDT, clock.now()), + ).getOrThrow() + assertTrue(restarted.attempts.value.single().paymentStarted) + assertEquals( + setOf(recurring.id), + restarted.protectedRequestIdsForSubscriptionCancellation(identity, subscription).getOrThrow() + ) + assertTrue( + restarted.protectedRequestIdsForSubscriptionCancellation(contact, subscription).getOrThrow().isEmpty() + ) + val otherWallet = "0x2222222222222222222222222222222222222222" + core.`when` { usdtParsePaymentRequest(otherWallet) } + .thenReturn(UsdtPaymentRequest(otherWallet, null, null)) + val otherEndpoint = PaykitUsdt.endpoint(otherWallet) + whenever(usdt.paymentEndpoint()).thenReturn(Result.success(otherEndpoint)) + assertTrue( + restarted.protectedRequestIdsForSubscriptionCancellation(identity, subscription).getOrThrow().isEmpty() + ) + val ownEndpoint = PaykitUsdt.endpoint(address) + whenever(usdt.paymentEndpoint()).thenReturn(Result.success(ownEndpoint)) + stubStoredTransfer( + Result.success( + mock { + on { status }.thenReturn(UsdtTransferStatus.FAILED) + } + ) + ) + assertTrue( + restarted.protectedRequestIdsForSubscriptionCancellation(identity, subscription).getOrThrow().isEmpty() + ) + } + + @Test + fun `execution authorization failure never dispatches and releases an unsubmitted attempt`() = test { + val repo = repo() + repo.prepare(context(), quote, amount, request.payment(PaykitAsset.USDT, clock.now())).getOrThrow() + val result = repo.send(quote) { throw PaykitPaymentRequestError.RequestUnavailable } + assertTrue(result.isFailure) + org.mockito.kotlin.verify(usdt, org.mockito.kotlin.never()).send(any()) + assertEquals(false, repo.attempts.value.single().paymentStarted) + } + + @Test + fun `binding survives restart and blocks replacement of a pending payment`() = test { + repo().prepare(context(), quote, amount, request.payment(PaykitAsset.USDT, clock.now())).getOrThrow() + assertNotNull(stored) + val pending = mock { on { status }.thenReturn(UsdtTransferStatus.PENDING) } + stubStoredTransfer(Result.success(pending)) + val restarted = repo() + assertTrue( + restarted.prepare( + context(), + quote.copy(id = "replacement"), + amount, + request.payment(PaykitAsset.USDT, clock.now()) + ).isFailure + ) + restarted.reconcile().getOrThrow() + assertEquals(quote.id, restarted.attempts.value.single().quoteId) + assertTrue(restarted.resumableRequests.value.isEmpty()) + stubStoredTransfer(Result.success(null)) + restarted.reconcile().getOrThrow() + assertEquals(setOf(request.id), restarted.resumableRequests.value) + restarted.prepare( + context(), + quote.copy(id = "replacement"), + amount, + request.payment(PaykitAsset.USDT, clock.now()) + ).getOrThrow() + assertEquals("replacement", restarted.attempts.value.single().quoteId) + } + + @Test + fun `restored started payment remains protected without local core history`() = test { + val original = repo() + original.prepare(context(), quote, amount, request.payment(PaykitAsset.USDT, clock.now())).getOrThrow() + val unstartedState = stored + whenever(usdt.send(quote)).thenReturn(Result.success(mock())) + original.send(quote).getOrThrow() + val backup = original.backupSnapshot() + for (localState in listOf(null, unstartedState)) { + stored = localState + val restored = repo() + restored.restoreBackup(backup) + restored.reconcile().getOrThrow() + assertTrue(restored.resumableRequests.value.isEmpty()) + assertTrue( + restored.prepare( + context(), + quote.copy(id = "replacement"), + amount, + request.payment(PaykitAsset.USDT, clock.now()) + ).isFailure + ) + assertEquals(backup, restored.backupSnapshot()) + } + } + + @Test + fun `failed send allows replacement only when its execution journal confirms no submission`() = test { + val pending = mock { on { status }.thenReturn(UsdtTransferStatus.PENDING) } + val histories = listOf( + Result.success(null), + Result.success(pending), + Result.failure(UsdtException.Storage("unreadable history")), + ) + for (history in histories) { + stored = null + val repo = repo() + stubStoredTransfer(history) + whenever(usdt.send(quote)).thenReturn(Result.failure(UsdtException.QuoteExpired())) + repo.prepare(context(), quote, amount, request.payment(PaykitAsset.USDT, clock.now())).getOrThrow() + assertTrue(repo.send(quote).isFailure) + val replacement = repo.prepare( + context(), + quote.copy(id = "replacement"), + amount, + request.payment(PaykitAsset.USDT, clock.now()) + ) + assertEquals(history.isSuccess && history.getOrNull() == null, replacement.isSuccess) + } + } + + @Test + fun `unreadable persistence prevents sending and is preserved`() = test { + stored = "unreadable" + assertTrue(repo().prepare(context(), quote, amount, request.payment(PaykitAsset.USDT, clock.now())).isFailure) + assertEquals("unreadable", stored) + } + + @Test + fun `preparation requires the approved amount recipient and accepted endpoint`() = test { + val repo = repo() + assertTrue( + repo.prepare( + context(), + quote.copy(amount = 49_999u), + amount, + request.payment(PaykitAsset.USDT, clock.now()) + ).isFailure + ) + assertTrue( + repo.prepare( + context(), + quote.copy(recipient = "0x2222222222222222222222222222222222222222"), + amount, + request.payment(PaykitAsset.USDT, clock.now()) + ).isFailure + ) + assertTrue( + repo.prepare( + context(request.copy(acceptedPaymentEndpointIdentifiers = listOf(MethodId.Bolt11.rawValue))), + quote, + amount, + request.payment(PaykitAsset.USDT, clock.now()) + ).isFailure + ) + assertEquals(null, stored) + repo.prepare(context(), quote, amount, request.payment(PaykitAsset.USDT, clock.now())).getOrThrow() + } + + @Test + fun `proof delivery can retry after restart without replacing the payment`() = test { + repo().prepare(context(), quote, amount, request.payment(PaykitAsset.USDT, clock.now())).getOrThrow() + val confirmed = mock { + on { status }.thenReturn(UsdtTransferStatus.CONFIRMED) + on { txHash }.thenReturn("transaction") + } + stubStoredTransfer(Result.success(confirmed)) + whenever(proofs.submit(any())).thenReturn(Result.success(false), Result.success(true)) + val first = repo() + first.reconcile().getOrThrow() + assertEquals(false, first.attempts.value.single().proofQueued) + val restarted = repo() + restarted.reconcile().getOrThrow() + assertEquals(true, restarted.attempts.value.single().proofQueued) + assertTrue( + restarted.prepare( + context(), + quote.copy(id = "replacement"), + amount, + request.payment(PaykitAsset.USDT, clock.now()) + ).isFailure + ) + } + + @Test + fun `receipt verification uses actual funds and claims each payment once`() = test { + val record = receivedRequest() + val second = receivedRequest("550e8400-e29b-41d4-a716-446655440001") + whenever(sdk.paymentRequests()).thenReturn(listOf(record, second)) + val payment = UsdtVerifiedPayment( + "42161:transaction:0", + "transaction:0", + "sender", + address, + 49_999u, + 1_800_000_000u + ) + stubVerification(Result.success(payment)) + val repo = repo() + repo.reconcile().getOrThrow() + assertEquals(1, repo.receipts.value.size) + assertEquals(49_999uL, repo.receipts.value.single().amount.atomic) + assertEquals(false, repo.receipts.value.single().satisfied) + repo.reconcile().getOrThrow() + assertEquals(1, repo.receipts.value.size) + assertEquals(quote.amount - 1u, repo.receipts.value.single().amount.atomic) + } + + @Test + fun `recurring receipt verifies the selected quote and verbatim proof period`() = test { + val period = BillingPeriod("2027-01-01T08:00:00.000Z", "2027-02-01T08:00:00.000Z") + val quoteId = "650e8400-e29b-41d4-a716-446655440000" + val base = receivedRequest() + val submission = base.paymentProofs.single() + whenever(submission.billingPeriod).thenReturn(period) + whenever(submission.conversionQuoteId).thenReturn(quoteId) + val record = base.copy( + state = PaymentRequestLifecycleState.ACTIVE_RECURRING, + terms = requireNotNull(base.terms).copy( + recurrence = PaymentRequestRecurrence(1u, "month", period.startsAt, period.startsAt, null), + conversion = PaymentConversion.PerPeriod, + ), + conversionQuotes = listOf( + PaymentConversionQuoteRecord( + quoteId, + period, + listOf(ConversionRate("usdt", "1")), + period.startsAt, + period.endsAt, + null, + ) + ), + ) + whenever(sdk.paymentRequests()).thenReturn(listOf(record)) + stubVerification( + Result.success( + UsdtVerifiedPayment("42161:transaction:0", "transaction:0", "sender", address, 50_000u, 1_800_000_000u) + ) + ) + val unverified = requireNotNull(record.toPaykitSubscription()) + assertTrue(unverified.paidPeriods.isEmpty()) + assertEquals(1, unverified.receivedPaymentRequests().size) + val repo = repo() + repo.reconcile().getOrThrow() + val receipts = repo.verifiedReceipts(identity).getOrThrow() + assertEquals(1, record.toPaykitSubscription(verifiedUsdtReceipts = receipts)?.paidPeriods?.size) + assertUnsatisfiedReceiptsDoNotPayPeriod(record, receipts.single()) + val binding = argumentCaptor() + verify(wallet).verifyPaymentProof(binding.capture(), any()) + assertEquals(period.startsAt, binding.firstValue.periodStartsAt) + assertEquals(period.endsAt, binding.firstValue.periodEndsAt) + assertEquals(quoteId, binding.firstValue.conversionQuoteId) + assertTrue(repo.receipts.value.single().satisfied) + assertEquals( + Instant.parse(period.startsAt), + repo.receipts.value.single().requestId.billingPeriodStartsAt?.let(Instant::parse) + ) + } + + private fun assertUnsatisfiedReceiptsDoNotPayPeriod(record: PaymentRequestRecord, receipt: PaykitUsdtReceipt) { + for (invalidReceipt in listOf( + receipt.copy(underpaid = true), + receipt.copy(afterExpiry = true), + receipt.copy(verified = false), + receipt.copy(proofEventId = "unrelated") + )) { + assertTrue( + requireNotNull( + record.toPaykitSubscription(verifiedUsdtReceipts = listOf(invalidReceipt)) + ).paidPeriods.isEmpty() + ) + } + } + + @Test + fun `receipt status survives restart and reflects canonical execution and payment deadline`() = test { + val record = receivedRequest().let { + it.copy( + terms = it.terms?.copy( + paymentDeadline = com.synonym.paykit.PaymentDeadline.At(clock.now().toString()) + ) + ) + } + whenever(sdk.paymentRequests()).thenReturn(listOf(record)) + val paid = UsdtVerifiedPayment( + "42161:transaction:0", + "transaction:0", + "sender", + address, + 50_000u, + 1_800_000_000u + ) + stubVerification(Result.success(paid)) + repo().reconcile().getOrThrow() + val restarted = repo() + restarted.reconcile().getOrThrow() + assertTrue(restarted.receipts.value.single().satisfied) + stubVerification(Result.failure(UsdtException.NetworkUnavailable())) + assertTrue(restarted.reconcile().isFailure) + assertTrue(restarted.receipts.value.single().verified) + stubVerification(Result.success(null)) + restarted.reconcile().getOrThrow() + assertEquals(false, restarted.receipts.value.single().verified) + stubVerification(Result.success(paid.copy(timestamp = paid.timestamp + 1u))) + restarted.reconcile().getOrThrow() + assertTrue(restarted.receipts.value.single().verified) + assertTrue(restarted.receipts.value.single().afterExpiry) + assertEquals(false, restarted.receipts.value.single().satisfied) + } + + @Test + fun `proof envelope includes the application id at the UTF-8 message boundary`() { + val binding = PaykitUsdtPaymentRepo.binding(request, identity, "bitkit", null, null) + // The rc63 envelope and largest ERC-20 receipt proof reserve 692 bytes before the reference. + val exactLimit = binding.copy(paymentReference = "é".repeat(154)) + PaykitUsdtPaymentRepo.validateProofSize(exactLimit) + kotlin.test.assertFailsWith { + PaykitUsdtPaymentRepo.validateProofSize( + exactLimit.copy(paymentReference = exactLimit.paymentReference + "x") + ) + } + } + + @Test + fun `proof size is bounded before the payment is prepared`() = test { + val binding = PaykitUsdtPaymentRepo.binding(request, identity, "bitkit", null, request.billingPeriod?.sdkValue) + PaykitUsdtPaymentRepo.validateProofSize(binding) + val oversized = context(request.copy(paymentReference = "é".repeat(256))) + assertTrue(repo().prepare(oversized, quote, amount, request.payment(PaykitAsset.USDT, clock.now())).isFailure) + assertEquals(null, stored) + } + + @Test + fun `invalid evidence does not prevent another request from completing`() = test { + val records = listOf(receivedRequest(), receivedRequest("550e8400-e29b-41d4-a716-446655440001")) + whenever(sdk.paymentRequests()).thenReturn(records) + val payment = UsdtVerifiedPayment( + "42161:transaction:0", + "transaction:0", + "sender", + address, + 50_000u, + 1_800_000_000u + ) + stubVerification( + Result.failure(UsdtException.InvalidPaymentProof()), + Result.success(payment) + ) + val repo = repo() + repo.reconcile().getOrThrow() + assertEquals(records.last().paymentRequestId, repo.receipts.value.single().requestId.paymentRequestId) + assertEquals(true, repo.receipts.value.single().satisfied) + } + + private fun receivedRequest(id: String = request.paymentRequestId): PaymentRequestRecord { + val json = Json.encodeToString( + PaykitUsdtProof(UsdtPaymentProof("42161", "0x" + "a".repeat(64), "0", "0x" + "b".repeat(130))) + ) + val proof = mock { on { exportText() }.thenReturn(json) } + val submission = mock { + on { eventId }.thenReturn("proof-$id") + on { billingPeriod }.thenReturn(null) + on { paymentAppId }.thenReturn("bitkit") + on { paymentEndpointIdentifier }.thenReturn(MethodId.UsdtArbitrum.rawValue) + on { this.proof }.thenReturn(proof) + } + val reference = mock { on { exportText() }.thenReturn("payment-reference") } + return PaymentRequestRecord( + counterparty = contact, paymentRequestId = id, + localRole = PaymentRequestLocalRole.PAYEE, state = PaymentRequestLifecycleState.PROOF_SUBMITTED, + proposalStreamItemId = 1u, proposalOutboundMessageId = null, proposalOutboundStatus = null, + proposalEventId = "proposal", + proposalAppId = "bitkit", + payerAppId = "bitkit", + executionClaimAppId = "bitkit", + terms = PaymentRequestTerms( + PaymentRequestAmount("0.05", "usd"), + reference, + null, + null, + listOf(MethodId.UsdtArbitrum.rawValue), + null, "bitkit", + PaymentConversion.Fixed(listOf(ConversionRate("usdt", "1"))), + null, + mock() + ), + acceptedEventId = "accepted", acceptedOutboundStatus = null, + rejectedEventId = null, rejectedOutboundStatus = null, + canceledEventId = null, canceledOutboundStatus = null, + paymentProofs = listOf( + submission + ), + conversionQuotes = emptyList(), + lastStreamItemId = 2u, + lastOutboundMessageId = null, lastOutboundStatus = null, + lastEventAt = "2027-01-15T08:00:00Z", invalidReason = null, + ) + } + + @Test + fun `both request participants construct the same reference`() { + val outgoing = request.copy(counterparty = identity, direction = PaykitPaymentRequestDirection.Outgoing) + val reference = PaykitUsdtPaymentRepo.binding( + request, + identity, + "bitkit", + null, + request.billingPeriod?.sdkValue + ) + assertEquals( + reference, + PaykitUsdtPaymentRepo.binding(outgoing, contact, "bitkit", null, outgoing.billingPeriod?.sdkValue) + ) + assertTrue( + reference != PaykitUsdtPaymentRepo.binding( + request.copy(paymentReference = "other"), identity, "bitkit", null, null + ) + ) + } + + @Test + fun `endpoint requires a direct address and the pinned network and token`() { + val endpoint = PaykitUsdt.endpoint(address) + assertEquals(address, PaykitUsdt.address(endpoint.rawPayload)) + for (invalid in listOf( + endpoint.rawPayload.replace("42161", "1"), + endpoint.rawPayload.replace(PaykitUsdt.TOKEN, address), + endpoint.rawPayload.replace("\"42161\"", "42161"), + endpoint.rawPayload.replace(address, endpoint.paymentRequest) + )) { + assertEquals(null, PaykitUsdt.address(invalid)) + } + } +} diff --git a/app/src/test/java/to/bitkit/repositories/PrivatePaykitRepoTest.kt b/app/src/test/java/to/bitkit/repositories/PrivatePaykitRepoTest.kt index d6f59fbdaa..240f10b6c3 100644 --- a/app/src/test/java/to/bitkit/repositories/PrivatePaykitRepoTest.kt +++ b/app/src/test/java/to/bitkit/repositories/PrivatePaykitRepoTest.kt @@ -59,6 +59,8 @@ import to.bitkit.data.PrivatePaykitContactCacheData import to.bitkit.data.SettingsData import to.bitkit.data.SettingsStore import to.bitkit.models.NodeLifecycleState +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset import to.bitkit.services.CoreService import to.bitkit.services.PaykitPreparedPrivateContactPayment import to.bitkit.services.PaykitPrivateContactPaymentResolution @@ -107,7 +109,7 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { private val clock = mock() private val cacheData = MutableStateFlow(PrivatePaykitCacheData()) - private val settingsData = MutableStateFlow(SettingsData()) + private val settingsData = MutableStateFlow(SettingsData(publicPaykitUsdtEnabled = false)) private val lightningState = MutableStateFlow( LightningState(nodeLifecycleState = NodeLifecycleState.Running), ) @@ -117,7 +119,7 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { @Before fun setUp() = test { cacheData.value = PrivatePaykitCacheData() - settingsData.value = SettingsData() + settingsData.value = SettingsData(publicPaykitUsdtEnabled = false) whenever(cacheStore.data).thenReturn(cacheData) whenever { cacheStore.update(any()) }.thenAnswer { @@ -388,6 +390,7 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { @Test fun `prepareSavedContacts publishes private reservations through SDK`() = test { settingsData.value = SettingsData( + publicPaykitUsdtEnabled = false, sharesPrivatePaykitEndpoints = true, publicPaykitLightningEnabled = false, publicPaykitOnchainEnabled = true, @@ -1563,6 +1566,7 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { @Test fun `prepareSavedContacts defers reservations while link preparation is unavailable`() = test { settingsData.value = SettingsData( + publicPaykitUsdtEnabled = false, sharesPrivatePaykitEndpoints = true, publicPaykitLightningEnabled = false, publicPaykitOnchainEnabled = true, @@ -1581,6 +1585,7 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { @Test fun `private message drain keeps retrying while link is still pending`() = test { settingsData.value = SettingsData( + publicPaykitUsdtEnabled = false, sharesPrivatePaykitEndpoints = true, publicPaykitLightningEnabled = false, publicPaykitOnchainEnabled = true, @@ -1851,6 +1856,7 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { @Test fun `prepareSavedContacts includes lightning payment hash in reservation attribution`() = test { settingsData.value = SettingsData( + publicPaykitUsdtEnabled = false, sharesPrivatePaykitEndpoints = true, publicPaykitLightningEnabled = true, publicPaykitOnchainEnabled = false, @@ -1881,6 +1887,7 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { @Test fun `publication skips contacts without Paykit and cleanup has nothing to withdraw`() = test { settingsData.value = SettingsData( + publicPaykitUsdtEnabled = false, sharesPrivatePaykitEndpoints = true, publicPaykitLightningEnabled = false, publicPaykitOnchainEnabled = true, @@ -2027,6 +2034,7 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { coreService = coreService, paykitSdkService = paykitSdkService, settingsStore = settingsStore, + usdtRepo = mock(), clock = clock, ) for (failureStage in listOf("withdraw", "disable capability")) { @@ -2113,6 +2121,7 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { @Test fun `disable sharing removes onchain-only private publications from cache`() = test { settingsData.value = SettingsData( + publicPaykitUsdtEnabled = false, sharesPrivatePaykitEndpoints = true, publicPaykitLightningEnabled = false, publicPaykitOnchainEnabled = true, @@ -2130,6 +2139,7 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { @Test fun `disable sharing reports unavailable endpoint cleanup and retains retry state`() = test { settingsData.value = SettingsData( + publicPaykitUsdtEnabled = false, sharesPrivatePaykitEndpoints = true, publicPaykitLightningEnabled = false, publicPaykitOnchainEnabled = true, @@ -2160,6 +2170,7 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { fun `enabling sharing supersedes deferred cleanup`() = test { cacheData.value = cacheData.value.copy(cleanupPending = true) settingsData.value = SettingsData( + publicPaykitUsdtEnabled = false, sharesPrivatePaykitEndpoints = true, publicPaykitLightningEnabled = false, publicPaykitOnchainEnabled = true, @@ -2174,6 +2185,7 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { @Test fun `disabled sharing retries cached publications without cleanup marker`() = test { settingsData.value = SettingsData( + publicPaykitUsdtEnabled = false, sharesPrivatePaykitEndpoints = true, publicPaykitLightningEnabled = false, publicPaykitOnchainEnabled = true, @@ -2191,6 +2203,7 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { @Test fun `disabled publication recovery remains pending when local cleanup fails`() = test { settingsData.value = SettingsData( + publicPaykitUsdtEnabled = false, sharesPrivatePaykitEndpoints = true, publicPaykitLightningEnabled = false, publicPaykitOnchainEnabled = true, @@ -2213,6 +2226,7 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { @Test fun `cleanup removal marks cleanup pending when private endpoint removal fails`() = test { settingsData.value = SettingsData( + publicPaykitUsdtEnabled = false, sharesPrivatePaykitEndpoints = true, publicPaykitLightningEnabled = false, publicPaykitOnchainEnabled = true, @@ -2239,6 +2253,7 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { @Test fun `cleanup remains pending until queued clear is delivered`() = test { settingsData.value = SettingsData( + publicPaykitUsdtEnabled = false, sharesPrivatePaykitEndpoints = true, publicPaykitLightningEnabled = false, publicPaykitOnchainEnabled = true, @@ -2448,6 +2463,7 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { @Test fun `prepareSavedContacts records queued contacts when another contact cannot publish`() = test { settingsData.value = SettingsData( + publicPaykitUsdtEnabled = false, sharesPrivatePaykitEndpoints = true, publicPaykitLightningEnabled = false, publicPaykitOnchainEnabled = true, @@ -2472,6 +2488,7 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { @Test fun `prepareSavedContacts does not require a cached contact record`() = test { settingsData.value = SettingsData( + publicPaykitUsdtEnabled = false, sharesPrivatePaykitEndpoints = true, publicPaykitLightningEnabled = false, publicPaykitOnchainEnabled = true, @@ -2495,6 +2512,7 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { @Test fun `prepareSavedContacts does not publish while cleanup is pending`() = test { settingsData.value = SettingsData( + publicPaykitUsdtEnabled = false, sharesPrivatePaykitEndpoints = true, publicPaykitLightningEnabled = false, publicPaykitOnchainEnabled = true, @@ -2514,7 +2532,11 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { @Test fun `enabling returns before contact linking and repeated preparation is coalesced`() = test { - settingsData.value = SettingsData(sharesPrivatePaykitEndpoints = true, publicPaykitLightningEnabled = false) + settingsData.value = SettingsData( + publicPaykitUsdtEnabled = false, + sharesPrivatePaykitEndpoints = true, + publicPaykitLightningEnabled = false, + ) val linkStarted = CompletableDeferred() val resumeLink = CompletableDeferred() whenever(paykitSdkService.ensureLinkWithPeer(CONTACT_KEY)) doSuspendableAnswer { @@ -2715,6 +2737,14 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { PublicPaykitPaymentResult.Opened( paymentRequest = PRIVATE_BOLT11, privatePaymentContext = PrivatePaykitPaymentContext(mapOf(MethodId.Bolt11.rawValue to "bitkit"), 7uL), + endpoints = listOf( + Endpoint( + MethodId.Bolt11, + PRIVATE_BOLT11, + rawPayload = PublicPaykitRepo.serializePayload(PRIVATE_BOLT11), + appId = "bitkit" + ) + ), ), result, ) @@ -2724,6 +2754,7 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { @Test fun `beginSavedContactPayment resolves before starting local endpoint publication`() = test { settingsData.value = SettingsData( + publicPaykitUsdtEnabled = false, sharesPrivatePaykitEndpoints = true, publicPaykitLightningEnabled = false, publicPaykitOnchainEnabled = true, @@ -2759,6 +2790,7 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { @Test fun `beginSavedContactPayment runs one endpoint publish per contact at a time`() = test { settingsData.value = SettingsData( + publicPaykitUsdtEnabled = false, sharesPrivatePaykitEndpoints = true, publicPaykitLightningEnabled = false, publicPaykitOnchainEnabled = true, @@ -2804,6 +2836,14 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { PublicPaykitPaymentResult.Opened( paymentRequest = PRIVATE_BOLT11, privatePaymentContext = PrivatePaykitPaymentContext(mapOf(MethodId.Bolt11.rawValue to "bitkit"), 7uL), + endpoints = listOf( + Endpoint( + MethodId.Bolt11, + PRIVATE_BOLT11, + rawPayload = PublicPaykitRepo.serializePayload(PRIVATE_BOLT11), + appId = "bitkit" + ) + ), ), result, ) @@ -2862,6 +2902,14 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { PublicPaykitPaymentResult.Opened( paymentRequest = SERVER_PRIVATE_BOLT11, privatePaymentContext = PrivatePaykitPaymentContext(mapOf(MethodId.Bolt11.rawValue to "bitkit"), 7uL), + endpoints = listOf( + Endpoint( + MethodId.Bolt11, + SERVER_PRIVATE_BOLT11, + rawPayload = PublicPaykitRepo.serializePayload(SERVER_PRIVATE_BOLT11), + appId = "bitkit" + ) + ), ), opened, ) @@ -2934,6 +2982,14 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { PublicPaykitPaymentResult.Opened( paymentRequest = PRIVATE_BOLT11, privatePaymentContext = PrivatePaykitPaymentContext(mapOf(MethodId.Bolt11.rawValue to "bitkit"), 7uL), + endpoints = listOf( + Endpoint( + MethodId.Bolt11, + PRIVATE_BOLT11, + rawPayload = PublicPaykitRepo.serializePayload(PRIVATE_BOLT11), + appId = "bitkit" + ) + ), ), result, ) @@ -3084,6 +3140,14 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { PublicPaykitPaymentResult.Opened( paymentRequest = SERVER_PRIVATE_BOLT11, privatePaymentContext = PrivatePaykitPaymentContext(mapOf(MethodId.Bolt11.rawValue to "bitkit"), 7uL), + endpoints = listOf( + Endpoint( + MethodId.Bolt11, + SERVER_PRIVATE_BOLT11, + rawPayload = """{"value":"$SERVER_PRIVATE_BOLT11"}""", + appId = "bitkit" + ) + ), ), result, ) @@ -3121,6 +3185,14 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { PublicPaykitPaymentResult.Opened( paymentRequest = PRIVATE_BOLT11, privatePaymentContext = PrivatePaykitPaymentContext(mapOf(MethodId.Bolt11.rawValue to "bitkit"), 7uL), + endpoints = listOf( + Endpoint( + MethodId.Bolt11, + PRIVATE_BOLT11, + rawPayload = PublicPaykitRepo.serializePayload(PRIVATE_BOLT11), + appId = "bitkit" + ) + ), ), result, ) @@ -3159,6 +3231,14 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { PublicPaykitPaymentResult.Opened( paymentRequest = SERVER_PRIVATE_BOLT11, privatePaymentContext = PrivatePaykitPaymentContext(mapOf(MethodId.Bolt11.rawValue to "bitkit"), 7uL), + endpoints = listOf( + Endpoint( + MethodId.Bolt11, + SERVER_PRIVATE_BOLT11, + rawPayload = PublicPaykitRepo.serializePayload(SERVER_PRIVATE_BOLT11), + appId = "bitkit" + ) + ), ), result, ) @@ -3186,7 +3266,21 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { val request = paymentRequest(listOf(MethodId.P2wpkh.rawValue)).copy(paymentRequestId = id) val result = sut.beginPaymentRequest(request).getOrThrow() val context = PrivatePaykitPaymentContext(mapOf(MethodId.P2wpkh.rawValue to "bitkit"), null) - assertEquals(PublicPaykitPaymentResult.Opened(addresses.getValue(id), context), result) + assertEquals( + PublicPaykitPaymentResult.Opened( + addresses.getValue(id), + context, + listOf( + Endpoint( + MethodId.P2wpkh, + addresses.getValue(id), + rawPayload = PublicPaykitRepo.serializePayload(addresses.getValue(id)), + appId = "bitkit" + ) + ) + ), + result + ) sut.consumePrivatePaymentList(CONTACT_KEY, context).getOrThrow() sut.releasePrivatePaymentList(CONTACT_KEY, context).getOrThrow() assertEquals(7uL, cacheData.value.contacts.getValue(CONTACT_KEY).consumedPrivatePaymentListVersion) @@ -3236,6 +3330,14 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { val expected = PublicPaykitPaymentResult.Opened( PRIVATE_ADDRESS, PrivatePaykitPaymentContext(mapOf(MethodId.P2wpkh.rawValue to "bitkit"), null), + endpoints = listOf( + Endpoint( + MethodId.P2wpkh, + PRIVATE_ADDRESS, + rawPayload = PublicPaykitRepo.serializePayload(PRIVATE_ADDRESS), + appId = "bitkit", + ), + ), ) assertEquals(expected, sut.beginPaymentRequest(request).getOrThrow()) @@ -3332,6 +3434,7 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { walletRepo = walletRepo, publicPaykitRepo = publicPaykitRepo, paymentRequestRepo = paymentRequestRepo, + usdtRepo = mock(), coreService = coreService, clock = clock, ).also { it.setContactPreparationActive(true) } @@ -3376,8 +3479,8 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { ) = PaykitPaymentRequest( paymentRequestId = "request-id", counterparty = CONTACT_KEY, - amountValue = "0.000025", - amountSats = 2_500uL, + paymentReference = "test-reference", + amount = PaykitAmount(PaykitAsset.BTC, 2_500uL), expiresAt = Instant.fromEpochSeconds(NOW_SECONDS + 60), acceptedPaymentEndpointIdentifiers = acceptedEndpointIdentifiers, ) diff --git a/app/src/test/java/to/bitkit/repositories/PublicPaykitRepoTest.kt b/app/src/test/java/to/bitkit/repositories/PublicPaykitRepoTest.kt index 0c55c000ca..0d40b7cc7e 100644 --- a/app/src/test/java/to/bitkit/repositories/PublicPaykitRepoTest.kt +++ b/app/src/test/java/to/bitkit/repositories/PublicPaykitRepoTest.kt @@ -65,7 +65,7 @@ class PublicPaykitRepoTest : BaseUnitTest() { @Before fun setUp() = test { sut = createRepo() - settingsFlow.value = SettingsData() + settingsFlow.value = SettingsData(publicPaykitUsdtEnabled = false) publicKey.value = "pubkyself" isRestoringSession.value = false walletState.value = WalletState() @@ -149,6 +149,7 @@ class PublicPaykitRepoTest : BaseUnitTest() { @Test fun `syncPublishedEndpoints creates reusable onchain endpoint when cached address is blank`() = test { settingsFlow.value = SettingsData( + publicPaykitUsdtEnabled = false, publicPaykitLightningEnabled = false, publicPaykitOnchainEnabled = true, ) @@ -171,6 +172,7 @@ class PublicPaykitRepoTest : BaseUnitTest() { @Test fun `syncPublishedEndpoints does not publish endpoints when app registration fails`() = test { settingsFlow.value = SettingsData( + publicPaykitUsdtEnabled = false, publicPaykitLightningEnabled = false, publicPaykitOnchainEnabled = true, ) @@ -190,6 +192,7 @@ class PublicPaykitRepoTest : BaseUnitTest() { for (priority in listOf(Priority.Ordered, Priority.Interactive)) { clearInvocations(paykitSdkService) settingsFlow.value = SettingsData( + publicPaykitUsdtEnabled = false, publicPaykitBolt11 = "lnbc1old", publicPaykitBolt11PaymentHash = "010203", publicPaykitBolt11ExpiresAtMillis = freshExpiryMillis(), @@ -269,7 +272,7 @@ class PublicPaykitRepoTest : BaseUnitTest() { @Test fun `syncCurrentPublishedEndpoints returns NoSupportedEndpoint when endpoint is required`() = test { - settingsFlow.value = SettingsData(publicPaykitOnchainEnabled = false) + settingsFlow.value = SettingsData(publicPaykitUsdtEnabled = false, publicPaykitOnchainEnabled = false) whenever(lightningRepo.canReceive()).thenReturn(false) val error = sut.syncCurrentPublishedEndpoints(requireEndpoint = true).exceptionOrNull() @@ -295,7 +298,20 @@ class PublicPaykitRepoTest : BaseUnitTest() { val result = sut.beginPayment("pubkycontact").getOrThrow() - assertEquals(PublicPaykitPaymentResult.Opened(PUBLIC_BOLT11), result) + assertEquals( + PublicPaykitPaymentResult.Opened( + PUBLIC_BOLT11, + endpoints = listOf( + Endpoint( + MethodId.Bolt11, + PUBLIC_BOLT11, + rawPayload = PublicPaykitRepo.serializePayload(PUBLIC_BOLT11), + appId = "bitkit" + ) + ) + ), + result + ) } @Test @@ -315,7 +331,20 @@ class PublicPaykitRepoTest : BaseUnitTest() { val result = sut.beginPayment("pubkycontact").getOrThrow() - assertEquals(PublicPaykitPaymentResult.Opened(PUBLIC_BOLT11), result) + assertEquals( + PublicPaykitPaymentResult.Opened( + PUBLIC_BOLT11, + endpoints = listOf( + Endpoint( + MethodId.Bolt11, + PUBLIC_BOLT11, + rawPayload = PublicPaykitRepo.serializePayload(PUBLIC_BOLT11), + appId = "another-wallet" + ) + ) + ), + result + ) } } @@ -356,6 +385,7 @@ class PublicPaykitRepoTest : BaseUnitTest() { walletRepo = walletRepo, lightningRepo = lightningRepo, coreService = coreService, + usdtRepo = mock(), paykitSdkService = paykitSdkService, settingsStore = settingsStore, clock = clock, diff --git a/app/src/test/java/to/bitkit/repositories/TrezorRepoTest.kt b/app/src/test/java/to/bitkit/repositories/TrezorRepoTest.kt index 5692b3ff63..efb6c33d26 100644 --- a/app/src/test/java/to/bitkit/repositories/TrezorRepoTest.kt +++ b/app/src/test/java/to/bitkit/repositories/TrezorRepoTest.kt @@ -168,6 +168,9 @@ class TrezorRepoTest : BaseUnitTest() { path: String, ) = TrezorPublicKeyResponse( xpub = xpub, + xpubSegwit = null, + descriptor = null, + displayablePublicKey = xpub, path = path, publicKey = "pubkey", chainCode = "chaincode", diff --git a/app/src/test/java/to/bitkit/repositories/UsdtRepoTest.kt b/app/src/test/java/to/bitkit/repositories/UsdtRepoTest.kt new file mode 100644 index 0000000000..69c498b8af --- /dev/null +++ b/app/src/test/java/to/bitkit/repositories/UsdtRepoTest.kt @@ -0,0 +1,234 @@ +package to.bitkit.repositories + +import com.synonym.bitkitcore.UsdtDestination +import com.synonym.bitkitcore.UsdtException +import com.synonym.bitkitcore.UsdtQuote +import com.synonym.bitkitcore.UsdtTransfer +import com.synonym.bitkitcore.UsdtTransferStatus +import com.synonym.bitkitcore.UsdtWallet +import kotlinx.coroutines.CompletableDeferred +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.launch +import kotlinx.coroutines.test.runCurrent +import org.junit.Test +import org.mockito.kotlin.doSuspendableAnswer +import org.mockito.kotlin.mock +import org.mockito.kotlin.never +import org.mockito.kotlin.verify +import org.mockito.kotlin.whenever +import to.bitkit.services.UsdtService +import to.bitkit.test.BaseUnitTest +import kotlin.test.assertEquals +import kotlin.test.assertTrue + +@OptIn(ExperimentalCoroutinesApi::class) +class UsdtRepoTest : BaseUnitTest() { + private val service: UsdtService = mock() + private val wallet: UsdtWallet = mock() + private val transfer: UsdtTransfer = mock() + + @Test + fun `deposit operations finish before wipe clears wallet credentials`() = test { + val started = CompletableDeferred() + val finish = CompletableDeferred() + whenever(service.depositNetworks()).doSuspendableAnswer { + started.complete(Unit) + finish.await() + emptyList() + } + val repo = UsdtRepo(service, testDispatcher) + val deposits = UsdtDepositRepo(repo) + val request = launch { deposits.depositNetworks().getOrThrow() } + started.await() + var credentialsCleared = false + val wipe = launch { repo.wipe { credentialsCleared = true }.getOrThrow() } + runCurrent() + assertEquals(false, credentialsCleared) + verify(service, never()).wipe() + + finish.complete(Unit) + request.join() + wipe.join() + + assertTrue(credentialsCleared) + verify(service).wipe() + } + + @Test + fun `saved activity is published before an offline balance refresh fails`() = test { + whenever(service.wallet()).thenReturn(wallet) + whenever(wallet.receiveAddress()).thenReturn("address") + whenever(wallet.receiveUri()).thenReturn("uri") + whenever(wallet.history()).thenReturn(listOf(transfer)) + whenever(wallet.balance()).thenThrow(UsdtException.NetworkUnavailable()) + val repo = UsdtRepo(service, testDispatcher) + assertTrue(repo.refresh(true, force = true).isFailure) + assertEquals(listOf(transfer), repo.state.value.transfers) + assertEquals("address", repo.state.value.address) + } + + @Test + fun `history still updates after settlement fails`() = test { + whenever(service.wallet()).thenReturn(wallet) + whenever(wallet.receiveAddress()).thenReturn("address") + whenever(wallet.receiveUri()).thenReturn("uri") + whenever(wallet.history()).thenReturn(emptyList(), listOf(incoming("received"))) + whenever(wallet.balance()).thenReturn(1_000_000uL) + whenever(wallet.refreshTransfers()).thenThrow(UsdtException.NetworkUnavailable()) + whenever(wallet.syncHistory()).thenReturn(true) + val repo = UsdtRepo(service, testDispatcher) + assertTrue(repo.refresh(true, force = true).isFailure) + assertEquals(listOf(incoming("received")), repo.state.value.transfers) + assertTrue(repo.state.value.historyComplete) + verify(wallet).syncHistory() + } + + @Test + fun `throttled settlement does not request history`() = test { + whenever(service.wallet()).thenReturn(wallet) + whenever(wallet.receiveAddress()).thenReturn("address") + whenever(wallet.receiveUri()).thenReturn("uri") + whenever(wallet.history()).thenReturn(emptyList()) + whenever(wallet.balance()).thenReturn(1_000_000uL) + whenever(wallet.refreshTransfers()).thenThrow(UsdtException.RateLimited()) + val repo = UsdtRepo(service, testDispatcher) + assertTrue(repo.refresh(true, force = true).exceptionOrNull() is UsdtException.RateLimited) + verify(wallet, never()).syncHistory() + } + + @Test + fun `send presentation defers history without stopping settlement and resumes after dismissal`() = test { + whenever(service.wallet()).thenReturn(wallet) + whenever(wallet.receiveAddress()).thenReturn("address") + whenever(wallet.receiveUri()).thenReturn("uri") + whenever(wallet.history()).thenReturn(emptyList()) + whenever(wallet.refreshTransfers()).thenReturn(emptyList()) + whenever(wallet.syncHistory()).thenReturn(true) + val balance = CompletableDeferred() + whenever(wallet.balance()).doSuspendableAnswer { balance.await() } + val repo = UsdtRepo(service, testDispatcher) + val refresh = launch { repo.refresh(true, force = true).getOrThrow() } + runCurrent() + repo.isSendPresented = true + balance.complete(1_000_000uL) + refresh.join() + assertEquals(1_000_000uL, repo.state.value.balance) + verify(wallet).refreshTransfers() + verify(wallet, never()).syncHistory() + assertEquals(false, repo.state.value.historyComplete) + + repo.isSendPresented = false + repo.refresh(true, force = true).getOrThrow() + verify(wallet).syncHistory() + assertTrue(repo.state.value.historyComplete) + } + + @Test + fun `pending submission stays successful when subsequent history is unreadable`() = test { + val quote: UsdtQuote = mock() + whenever(service.wallet()).thenReturn(wallet) + whenever(wallet.history()).thenThrow(UsdtException.Storage("unreadable history")) + val submitted = incoming("submitted").copy( + isIncoming = false, + status = UsdtTransferStatus.PENDING, + txHash = null, + ) + whenever(service.send(quote)).thenReturn(submitted) + val repo = UsdtRepo(service, testDispatcher) + assertEquals(submitted, repo.send(quote).getOrThrow()) + assertEquals(listOf(submitted), repo.state.value.transfers) + } + + @Test + fun `only new confirmed receipts celebrate after initial sync`() = test { + whenever(service.wallet()).thenReturn(wallet) + whenever(wallet.receiveAddress()).thenReturn("address") + whenever(wallet.receiveUri()).thenReturn("uri") + whenever(wallet.balance()).thenReturn(1_000_000uL) + whenever(wallet.syncHistory()).thenReturn(true) + val old = incoming("old") + var history = listOf(old) + whenever(wallet.history()).thenAnswer { history } + whenever(wallet.refreshTransfers()).thenAnswer { history } + val repo = UsdtRepo(service, testDispatcher) + val events = mutableListOf() + val collector = launch { repo.receivedTxs.collect { events.add(it) } } + runCurrent() + try { + repo.refresh(true, force = true).getOrThrow() + runCurrent() + assertTrue(events.isEmpty()) + val received = incoming("new") + val pending = incoming("pending").copy(status = UsdtTransferStatus.PENDING, txHash = null) + history = listOf( + old, received, pending, incoming("sent").copy(isIncoming = false), + incoming("failed").copy(status = UsdtTransferStatus.FAILED), incoming("zero").copy(amount = 0uL) + ) + repo.refresh(true, force = true).getOrThrow() + runCurrent() + assertEquals(listOf(received), events) + repo.refresh(true, force = true).getOrThrow() + runCurrent() + assertEquals(listOf(received), events) + val confirmed = pending.copy(status = UsdtTransferStatus.CONFIRMED, txHash = "pending") + history = history.map { if (it.id == confirmed.id) confirmed else it } + repo.refresh(true, force = true).getOrThrow() + runCurrent() + assertEquals(listOf(received, confirmed), events) + whenever(wallet.receiveAddress()).thenReturn("another wallet") + history = listOf(incoming("restored")) + repo.refresh(true, force = true).getOrThrow() + runCurrent() + assertEquals(listOf(received, confirmed), events) + } finally { + collector.cancel() + } + } + + @Test + fun `partial history remains visible without declaring initial sync complete`() = test { + whenever(service.wallet()).thenReturn(wallet) + whenever(wallet.receiveAddress()).thenReturn("address") + whenever(wallet.receiveUri()).thenReturn("uri") + whenever(wallet.history()).thenReturn(listOf(incoming("old"))) + whenever(wallet.balance()).thenReturn(1_000_000uL) + whenever(wallet.refreshTransfers()).thenReturn(emptyList()) + whenever(wallet.syncHistory()).thenReturn(false, true) + val repo = UsdtRepo(service, testDispatcher) + repo.refresh(true, force = true).getOrThrow() + assertEquals(1_000_000uL, repo.state.value.balance) + assertEquals(listOf(incoming("old")), repo.state.value.transfers) + assertEquals(false, repo.state.value.historyComplete) + repo.refresh(true, force = true).getOrThrow() + assertTrue(repo.state.value.historyComplete) + } + + @Test + fun `execution checks bypass normal cooldown and preserve rate limit backoff`() = test { + whenever(service.wallet()).thenReturn(wallet) + whenever(wallet.receiveAddress()).thenReturn("address") + whenever(wallet.receiveUri()).thenReturn("uri") + whenever(wallet.history()).thenReturn(emptyList()) + whenever(wallet.balance()).thenReturn(1_000_000uL) + whenever(wallet.refreshTransfers()).thenReturn(emptyList()) + val sent = incoming("sent").copy(isIncoming = false) + whenever(wallet.checkRecentExecution("sent")).thenReturn(sent) + whenever(wallet.checkRecentExecution("limited")).thenThrow(UsdtException.RateLimited()) + val repo = UsdtRepo(service, testDispatcher) + repo.refresh(false).getOrThrow() + repo.waitForTransfer("sent").getOrThrow() + assertEquals(listOf(sent), repo.state.value.transfers) + assertTrue(repo.waitForTransfer("limited").exceptionOrNull() is UsdtException.RateLimited) + repo.waitForTransfer("backoff").getOrThrow() + verify(wallet, never()).checkRecentExecution("backoff") + repo.refresh(true, force = true).getOrThrow() + verify(wallet, never()).syncHistory() + } + + private fun incoming(id: String) = UsdtTransfer( + id = id, txHash = id, userOperationHash = null, bridgeGuid = null, orchestra = null, recipient = "recipient", + destination = UsdtDestination.ARBITRUM, amount = 1_000_000uL, receivedAmount = 1_000_000uL, + fee = null, isIncoming = true, status = UsdtTransferStatus.CONFIRMED, + timestamp = 1uL, + ) +} diff --git a/app/src/test/java/to/bitkit/ui/screens/paymentrequests/PaymentRequestPresentationTest.kt b/app/src/test/java/to/bitkit/ui/screens/paymentrequests/PaymentRequestPresentationTest.kt index 29d06c1924..86d9af2839 100644 --- a/app/src/test/java/to/bitkit/ui/screens/paymentrequests/PaymentRequestPresentationTest.kt +++ b/app/src/test/java/to/bitkit/ui/screens/paymentrequests/PaymentRequestPresentationTest.kt @@ -71,8 +71,8 @@ class PaymentRequestPresentationTest { ) = PaykitPaymentRequest( paymentRequestId = "request-id", counterparty = "pubky3rsduhcxpw74snwyct86m38c63j3pq8x4ycqikxg64roik8yw5xg", - amountValue = "0.000025", - amountSats = 2_500uL, + amount = to.bitkit.models.PaykitAmount(to.bitkit.models.PaykitAsset.BTC, 2_500uL), + paymentReference = "fixture-reference", expiresAt = null, acceptedPaymentEndpointIdentifiers = listOf("lightning-bolt11"), direction = direction, diff --git a/app/src/test/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalRetryTest.kt b/app/src/test/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalRetryTest.kt index c481ecac23..3a1b6a25fe 100644 --- a/app/src/test/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalRetryTest.kt +++ b/app/src/test/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalRetryTest.kt @@ -43,7 +43,7 @@ class PubkyAuthApprovalRetryTest : BaseUnitTest() { Result.failure(AppError(PubkyRingAuthTimeoutError())), Result.success(Unit), ) - val sut = PubkyAuthApprovalViewModel(context, pubkyRepo, mock()) + val sut = PubkyAuthApprovalViewModel(context, pubkyRepo, mock(), mock()) sut.effects.test { sut.load(authUrl) diff --git a/app/src/test/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalViewModelTest.kt b/app/src/test/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalViewModelTest.kt index c4dc97867b..33b68e0aee 100644 --- a/app/src/test/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalViewModelTest.kt +++ b/app/src/test/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalViewModelTest.kt @@ -3,12 +3,17 @@ package to.bitkit.ui.screens.profile import android.content.Context import android.util.Log import app.cash.turbine.test +import com.synonym.bitkitcore.UsdtPaymentRequest +import com.synonym.bitkitcore.usdtParsePaymentRequest import com.synonym.paykit.PubkyAuthCompanionClaimApprovalException import kotlinx.coroutines.CompletableDeferred import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.test.advanceUntilIdle import kotlinx.coroutines.test.runCurrent +import kotlinx.serialization.json.Json +import kotlinx.serialization.json.jsonObject +import kotlinx.serialization.json.jsonPrimitive import org.junit.Before import org.junit.Test import org.mockito.Mockito.mockStatic @@ -26,6 +31,7 @@ import org.mockito.kotlin.verifyBlocking import org.mockito.kotlin.verifyNoInteractions import org.mockito.kotlin.whenever import to.bitkit.R +import to.bitkit.models.PaykitUsdt import to.bitkit.models.PreparedWatchOnlyAccountClaim import to.bitkit.models.PubkyAuthClaim import to.bitkit.models.PubkyAuthClaim.Item @@ -36,11 +42,14 @@ import to.bitkit.models.WatchOnlyAccountRecord import to.bitkit.models.WatchOnlyAccountSetupState import to.bitkit.repositories.PubkyAlreadySignedInError import to.bitkit.repositories.PubkyRepo +import to.bitkit.repositories.UsdtRepo import to.bitkit.repositories.WatchOnlyAccountAuthorizationStartError import to.bitkit.repositories.WatchOnlyAccountRepo import to.bitkit.test.BaseUnitTest import to.bitkit.utils.AppError import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertTrue @OptIn(ExperimentalCoroutinesApi::class) @Suppress("LargeClass") @@ -57,6 +66,7 @@ class PubkyAuthApprovalViewModelTest : BaseUnitTest() { on { displayName } doReturn displayNameFlow on { displayImageUri } doReturn displayImageUriFlow } + private val usdtRepo: UsdtRepo = mock() private val watchOnlyAccountRepo: WatchOnlyAccountRepo = mock() @Before @@ -525,7 +535,9 @@ class PubkyAuthApprovalViewModelTest : BaseUnitTest() { assertEquals(ApprovalState.Success, sut.uiState.value.state) verifyBlocking(watchOnlyAccountRepo) { prepareUnsignedClaim(authUrl, "paykit server") } - verifyBlocking(pubkyRepo) { approveAuthWithCompanionClaim(authUrl, clientId, prepared.payload) } + verifyBlocking(pubkyRepo) { + approveAuthWithCompanionClaim(authUrl, clientId, prepared.payload) + } verifyBlocking(pubkyRepo, times(2)) { parseAuthUrl(authUrl) } verifyBlocking(pubkyRepo, never()) { approveAuth(authUrl, capabilities, clientId) } verifyBlocking(watchOnlyAccountRepo) { beginAuthorization(prepared.account.id) } @@ -561,7 +573,9 @@ class PubkyAuthApprovalViewModelTest : BaseUnitTest() { assertEquals(ApprovalState.Success, sut.uiState.value.state) verifyBlocking(watchOnlyAccountRepo, times(1)) { prepareUnsignedClaim(authUrl, "paykit server") } verifyBlocking(watchOnlyAccountRepo, times(1)) { beginAuthorization(prepared.account.id) } - verifyBlocking(pubkyRepo, times(1)) { approveAuthWithCompanionClaim(authUrl, clientId, prepared.payload) } + verifyBlocking(pubkyRepo, times(1)) { + approveAuthWithCompanionClaim(authUrl, clientId, prepared.payload) + } verifyBlocking(watchOnlyAccountRepo, times(1)) { markActive(prepared.account.id) } } @@ -584,7 +598,9 @@ class PubkyAuthApprovalViewModelTest : BaseUnitTest() { ) whenever { watchOnlyAccountRepo.prepareUnsignedClaim(authUrl, "paykit server") }.thenReturn(prepared) whenever { watchOnlyAccountRepo.beginAuthorization(prepared.account.id) }.thenReturn(false) - whenever { pubkyRepo.approveAuthWithCompanionClaim(authUrl, clientId, prepared.payload) } + whenever { + pubkyRepo.approveAuthWithCompanionClaim(authUrl, clientId, prepared.payload) + } .doSuspendableAnswer { approvalResult.await() } whenever { watchOnlyAccountRepo.markActive(prepared.account.id) }.thenReturn(Unit) val sut = createSut() @@ -617,7 +633,9 @@ class PubkyAuthApprovalViewModelTest : BaseUnitTest() { verifyBlocking(pubkyRepo, times(1)) { parseAuthUrl(secondAuthUrl) } verifyBlocking(watchOnlyAccountRepo, times(1)) { prepareUnsignedClaim(authUrl, "paykit server") } verifyBlocking(watchOnlyAccountRepo, times(1)) { beginAuthorization(prepared.account.id) } - verifyBlocking(pubkyRepo, times(1)) { approveAuthWithCompanionClaim(authUrl, clientId, prepared.payload) } + verifyBlocking(pubkyRepo, times(1)) { + approveAuthWithCompanionClaim(authUrl, clientId, prepared.payload) + } verifyBlocking(pubkyRepo, never()) { approveAuth(secondAuthUrl, secondCapabilities, clientId) } verifyBlocking(watchOnlyAccountRepo, times(1)) { markActive(prepared.account.id) } } @@ -638,7 +656,9 @@ class PubkyAuthApprovalViewModelTest : BaseUnitTest() { ) whenever { watchOnlyAccountRepo.prepareUnsignedClaim(authUrl, "paykit server") }.thenReturn(prepared) whenever { watchOnlyAccountRepo.beginAuthorization(prepared.account.id) }.thenReturn(false) - whenever { pubkyRepo.approveAuthWithCompanionClaim(authUrl, clientId, prepared.payload) } + whenever { + pubkyRepo.approveAuthWithCompanionClaim(authUrl, clientId, prepared.payload) + } .thenReturn(Result.failure(AppError(authorizationError))) val sut = createSut() @@ -667,7 +687,9 @@ class PubkyAuthApprovalViewModelTest : BaseUnitTest() { ) whenever { watchOnlyAccountRepo.prepareUnsignedClaim(authUrl, "paykit server") }.thenReturn(prepared) whenever { watchOnlyAccountRepo.beginAuthorization(prepared.account.id) }.thenReturn(false) - whenever { pubkyRepo.approveAuthWithCompanionClaim(authUrl, clientId, prepared.payload) } + whenever { + pubkyRepo.approveAuthWithCompanionClaim(authUrl, clientId, prepared.payload) + } .thenReturn(Result.failure(IllegalStateException("Relay delivery failed"))) val sut = createSut() @@ -700,7 +722,9 @@ class PubkyAuthApprovalViewModelTest : BaseUnitTest() { ) whenever { watchOnlyAccountRepo.prepareUnsignedClaim(authUrl, "paykit server") }.thenReturn(prepared) whenever { watchOnlyAccountRepo.beginAuthorization(prepared.account.id) }.thenReturn(true) - whenever { pubkyRepo.approveAuthWithCompanionClaim(authUrl, clientId, prepared.payload) } + whenever { + pubkyRepo.approveAuthWithCompanionClaim(authUrl, clientId, prepared.payload) + } .thenReturn(Result.failure(IllegalStateException("Relay delivery failed"))) val sut = createSut() @@ -747,7 +771,9 @@ class PubkyAuthApprovalViewModelTest : BaseUnitTest() { assertEquals(ApprovalState.Authorize, sut.uiState.value.state) verifyBlocking(watchOnlyAccountRepo) { cancelAuthorization(prepared.account.id) } - verifyBlocking(pubkyRepo, never()) { approveAuthWithCompanionClaim(authUrl, clientId, prepared.payload) } + verifyBlocking(pubkyRepo, never()) { + approveAuthWithCompanionClaim(authUrl, clientId, prepared.payload) + } verifyBlocking(watchOnlyAccountRepo, never()) { markActive(prepared.account.id) } } @@ -786,7 +812,9 @@ class PubkyAuthApprovalViewModelTest : BaseUnitTest() { verifyBlocking(watchOnlyAccountRepo) { cancelAuthorization(prepared.account.id, preserveAuthorizingState = true) } - verifyBlocking(pubkyRepo, never()) { approveAuthWithCompanionClaim(authUrl, clientId, prepared.payload) } + verifyBlocking(pubkyRepo, never()) { + approveAuthWithCompanionClaim(authUrl, clientId, prepared.payload) + } } @Test @@ -842,14 +870,110 @@ class PubkyAuthApprovalViewModelTest : BaseUnitTest() { assertEquals(ApprovalState.Success, restartedSut.uiState.value.state) verifyBlocking(watchOnlyAccountRepo, times(2)) { prepareUnsignedClaim(authUrl, "paykit server") } verifyBlocking(watchOnlyAccountRepo, times(2)) { beginAuthorization(prepared.account.id) } - verifyBlocking(pubkyRepo, times(2)) { approveAuthWithCompanionClaim(authUrl, clientId, prepared.payload) } + verifyBlocking(pubkyRepo, times(2)) { + approveAuthWithCompanionClaim(authUrl, clientId, prepared.payload) + } verifyBlocking(watchOnlyAccountRepo, times(2)) { markActive(prepared.account.id) } } + @Test + fun `receiving details share exactly the requested assets`() = test { + val address = "0x1111111111111111111111111111111111111111" + mockStatic(Class.forName("com.synonym.bitkitcore.Bitkitcore_androidKt")).use { core -> + core.`when` { usdtParsePaymentRequest(address) } + .thenReturn(UsdtPaymentRequest(address, null, null)) + val endpoint = PaykitUsdt.endpoint(address) + whenever(usdtRepo.paymentEndpoint()).thenReturn(Result.success(endpoint)) + for (claim in listOf(PubkyAuthClaim.USDT_ADDRESS_V1, PubkyAuthClaim.PAYMENT_DETAILS_V1)) { + clearInvocations(watchOnlyAccountRepo) + val url = "pubkyauth://signin_grant?x-bitkit-claim=${claim.wireValue}" + whenever( + pubkyRepo.parseAuthUrl(url) + ).thenReturn(Result.success(authRequest(url, PubkyAuthClaim.REQUIRED_CAPABILITIES, claim))) + val prepared = PreparedWatchOnlyAccountClaim(watchOnlyAccount(), byteArrayOf(1)) + whenever(watchOnlyAccountRepo.prepareUnsignedClaim(url, "paykit server")).thenReturn(prepared) + whenever(watchOnlyAccountRepo.beginAuthorization(prepared.account.id)).thenReturn(false) + var shared: ByteArray? = null + whenever(pubkyRepo.approveAuthWithCompanionClaim(eq(url), eq(clientId), any())) + .thenAnswer { + shared = it.getArgument(2) + Result.success(Unit) + } + val sut = createSut() + sut.load(url) + advanceUntilIdle() + assertEquals(ApprovalState.WatchOnlyConsent, sut.uiState.value.state) + sut.approveWatchOnlyConsent(url) + assertTrue(sut.uiState.value.canAuthorize) + sut.confirmAuthorize(url) + advanceUntilIdle() + assertEquals(ApprovalState.Success, sut.uiState.value.state) + val details = Json.parseToJsonElement(checkNotNull(shared).decodeToString()).jsonObject + val usdt = details.getValue("usdt-arbitrum-address").jsonObject + assertEquals(address, usdt.getValue("value").jsonPrimitive.content) + assertEquals(PaykitUsdt.CHAIN_ID, usdt.getValue("chain_id").jsonPrimitive.content) + assertEquals(PaykitUsdt.TOKEN, usdt.getValue("token").jsonPrimitive.content) + assertEquals( + if (claim.sharesBitcoin) { + setOf( + "bitcoin_account", + "usdt-arbitrum-address" + ) + } else { + setOf("usdt-arbitrum-address") + }, + details.keys + ) + if (claim.sharesBitcoin) { + assertEquals( + prepared.account.xpub, + details.getValue("bitcoin_account").jsonObject.getValue("xpub").jsonPrimitive.content + ) + verifyBlocking(watchOnlyAccountRepo) { markActive(prepared.account.id) } + } else { + verifyBlocking(watchOnlyAccountRepo, never()) { prepareUnsignedClaim(any(), any()) } + } + } + } + } + + @Test + fun `unavailable receiving address blocks approval and can be retried`() = test { + val url = "pubkyauth://signin_grant?x-bitkit-claim=usdt-address-v1" + whenever( + pubkyRepo.parseAuthUrl(url) + ).thenReturn( + Result.success( + authRequest(url, PubkyAuthClaim.REQUIRED_CAPABILITIES, PubkyAuthClaim.USDT_ADDRESS_V1) + ) + ) + whenever(usdtRepo.paymentEndpoint()).thenReturn(Result.failure(AppError("Unavailable"))) + val sut = createSut() + sut.load(url) + advanceUntilIdle() + sut.approveWatchOnlyConsent(url) + assertFalse(sut.uiState.value.canAuthorize) + assertTrue(sut.uiState.value.usdtUnavailable) + sut.requestAuthorize(url) + advanceUntilIdle() + assertEquals(ApprovalState.Authorize, sut.uiState.value.state) + val endpoint = to.bitkit.repositories.Endpoint( + methodId = to.bitkit.repositories.MethodId.UsdtArbitrum, + value = "reviewed-address", + rawPayload = "{}" + ) + whenever(usdtRepo.paymentEndpoint()).thenReturn(Result.success(endpoint)) + sut.loadUsdtAddress(url) + advanceUntilIdle() + assertTrue(sut.uiState.value.canAuthorize) + assertFalse(sut.uiState.value.usdtUnavailable) + } + private fun createSut() = PubkyAuthApprovalViewModel( context = context, pubkyRepo = pubkyRepo, watchOnlyAccountRepo = watchOnlyAccountRepo, + usdtRepo = usdtRepo, ) private fun authRequest( diff --git a/app/src/test/java/to/bitkit/ui/screens/subscriptions/SubscriptionsScreenTest.kt b/app/src/test/java/to/bitkit/ui/screens/subscriptions/SubscriptionsScreenTest.kt index 41a8f61c45..3d00cb3072 100644 --- a/app/src/test/java/to/bitkit/ui/screens/subscriptions/SubscriptionsScreenTest.kt +++ b/app/src/test/java/to/bitkit/ui/screens/subscriptions/SubscriptionsScreenTest.kt @@ -6,6 +6,9 @@ import com.synonym.paykit.PaymentRequestLifecycleState import org.junit.Test import to.bitkit.R import to.bitkit.models.NewTransactionSheetType +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset +import to.bitkit.models.PaykitRequestPricing import to.bitkit.repositories.PaykitBillingPeriod import to.bitkit.repositories.PaykitRecurrenceUnit import to.bitkit.repositories.PaykitSubscription @@ -53,14 +56,14 @@ class SubscriptionsScreenTest { cases.forEach { (unit, every, expectedSats) -> assertEquals( expectedSats, - subscriptionMonthlyCostSats(listOf(subscription(unit, every, 1_200u)), now), + subscriptionMonthlyCosts(listOf(subscription(unit, every, 1_200u)), now).single().atomic.toLong(), "Unexpected monthly cost for every '$every' '$unit'", ) } val lowCostYearlySubscriptions = List(3) { index -> subscription(PaykitRecurrenceUnit.Year, amountSats = 10u).copy(paymentRequestId = "low-cost-$index") } - assertEquals(3L, subscriptionMonthlyCostSats(lowCostYearlySubscriptions, now)) + assertEquals(3L, subscriptionMonthlyCosts(lowCostYearlySubscriptions, now).single().atomic.toLong()) } @Test @@ -111,7 +114,7 @@ class SubscriptionsScreenTest { assertEquals( 1_200L, - subscriptionMonthlyCostSats(listOf(paidActive, canceled, proposed), now), + subscriptionMonthlyCosts(listOf(paidActive, canceled, proposed), now).single().atomic.toLong(), ) } @@ -230,7 +233,7 @@ class SubscriptionsScreenTest { assertEquals(emptyList(), sections.active) assertEquals(emptyList(), sections.expired) assertEquals(paidThrough, nextSubscriptionTransition(listOf(created), now)) - assertEquals(0L, subscriptionMonthlyCostSats(listOf(created), now)) + assertEquals(0L, subscriptionMonthlyCosts(listOf(created), now).single().atomic.toLong()) } @Test @@ -319,10 +322,10 @@ class SubscriptionsScreenTest { @Test fun `monthly cost counts a canceled subscription until its paid period ends`() { - val canceled = canceledWithPaidThrough().copy(amountSats = 1_200u) + val canceled = canceledWithPaidThrough().copy(amount = PaykitAmount(PaykitAsset.BTC, 1_200u)) - assertEquals(1_200L, subscriptionMonthlyCostSats(listOf(canceled), now)) - assertEquals(0L, subscriptionMonthlyCostSats(listOf(canceled), paidThrough)) + assertEquals(1_200L, subscriptionMonthlyCosts(listOf(canceled), now).single().atomic.toLong()) + assertEquals(0L, subscriptionMonthlyCosts(listOf(canceled), paidThrough).single().atomic.toLong()) } @Test @@ -359,8 +362,9 @@ class SubscriptionsScreenTest { ) = PaykitSubscription( paymentRequestId = "subscription", counterparty = "pubkypayee", - amountValue = "0.001", - amountSats = amountSats, + amount = PaykitAmount(PaykitAsset.BTC, amountSats), + paymentReference = "fixture-reference", + pricing = PaykitRequestPricing(), note = "Subscription", createdAt = Instant.parse("2027-01-01T08:00:00Z"), proposalExpiresAt = null, diff --git a/app/src/test/java/to/bitkit/ui/screens/wallets/HomeViewModelTest.kt b/app/src/test/java/to/bitkit/ui/screens/wallets/HomeViewModelTest.kt index ea83f7dc1f..1c0cb0bb4a 100644 --- a/app/src/test/java/to/bitkit/ui/screens/wallets/HomeViewModelTest.kt +++ b/app/src/test/java/to/bitkit/ui/screens/wallets/HomeViewModelTest.kt @@ -17,6 +17,7 @@ import to.bitkit.R import to.bitkit.data.SettingsData import to.bitkit.data.SettingsStore import to.bitkit.data.WidgetsData +import to.bitkit.env.Env import to.bitkit.models.BalanceState import to.bitkit.models.HwWallet import to.bitkit.models.Suggestion @@ -28,9 +29,12 @@ import to.bitkit.repositories.HwWalletRepo import to.bitkit.repositories.PubkyRepo import to.bitkit.repositories.SuggestionsRepo import to.bitkit.repositories.TransferRepo +import to.bitkit.repositories.UsdtRepo +import to.bitkit.repositories.UsdtWalletState import to.bitkit.repositories.WalletRepo import to.bitkit.repositories.WidgetsRepo import to.bitkit.test.BaseUnitTest +import kotlin.test.assertEquals import kotlin.test.assertFalse import kotlin.test.assertTrue @@ -47,6 +51,8 @@ class HomeViewModelTest : BaseUnitTest() { private val activityRepo = mock() private val hwWalletRepo = mock() private val suggestionsRepo = mock() + private val usdtRepo = mock() + private val usdtState = MutableStateFlow(UsdtWalletState()) private lateinit var hardwareWallets: MutableStateFlow> private lateinit var suggestions: MutableStateFlow> @@ -74,6 +80,7 @@ class HomeViewModelTest : BaseUnitTest() { }.thenReturn(Result.success(emptyList())) whenever(hwWalletRepo.wallets).thenReturn(hardwareWallets) whenever(suggestionsRepo.suggestionsFlow).thenReturn(suggestions) + whenever(usdtRepo.state).thenReturn(usdtState) } @Test @@ -107,6 +114,17 @@ class HomeViewModelTest : BaseUnitTest() { assertFalse(sut.uiState.value.showEmptyState) } + @Test + fun `empty state follows the enabled USDT balance`() = test { + val sut = createViewModel() + advanceUntilIdle() + assertTrue(sut.uiState.value.showEmptyState) + + usdtState.value = UsdtWalletState(balance = 50_000uL) + advanceUntilIdle() + assertEquals(!Env.isUsdtEnabled, sut.uiState.value.showEmptyState) + } + @Test fun `onPullToRefresh refreshes rates and widgets`() = test { val sut = createViewModel() @@ -146,6 +164,7 @@ class HomeViewModelTest : BaseUnitTest() { activityRepo = activityRepo, hwWalletRepo = hwWalletRepo, suggestionsRepo = suggestionsRepo, + usdtRepo = usdtRepo, ) private fun hardwareWallet(balanceSats: ULong = 0uL) = HwWallet( diff --git a/app/src/test/java/to/bitkit/ui/screens/wallets/usdt/UsdtDepositViewModelTest.kt b/app/src/test/java/to/bitkit/ui/screens/wallets/usdt/UsdtDepositViewModelTest.kt new file mode 100644 index 0000000000..772ffd5ffa --- /dev/null +++ b/app/src/test/java/to/bitkit/ui/screens/wallets/usdt/UsdtDepositViewModelTest.kt @@ -0,0 +1,143 @@ +package to.bitkit.ui.screens.wallets.usdt + +import com.synonym.bitkitcore.UsdtDeposit +import com.synonym.bitkitcore.UsdtDepositAddress +import com.synonym.bitkitcore.UsdtDepositDetail +import com.synonym.bitkitcore.UsdtDepositNetwork +import com.synonym.bitkitcore.UsdtDepositOrder +import com.synonym.bitkitcore.UsdtDepositPage +import com.synonym.bitkitcore.UsdtException +import kotlinx.collections.immutable.persistentListOf +import kotlinx.coroutines.CompletableDeferred +import kotlinx.coroutines.cancelAndJoin +import org.junit.Test +import org.mockito.kotlin.doSuspendableAnswer +import org.mockito.kotlin.mock +import org.mockito.kotlin.times +import org.mockito.kotlin.verify +import org.mockito.kotlin.whenever +import to.bitkit.R +import to.bitkit.repositories.UsdtDepositRepo +import to.bitkit.test.BaseUnitTest +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertNull +import kotlin.test.assertTrue + +class UsdtDepositViewModelTest : BaseUnitTest() { + private val repo: UsdtDepositRepo = mock() + + @Test + fun `editing a rejected amount clears its error and limits`() = test { + whenever(repo.depositNetworks()).thenReturn(Result.success(persistentListOf(UsdtDepositNetwork.POLYGON))) + val error = UsdtException.DepositAmountOutOfRange("200", "1200000000") + whenever(repo.prepareDeposit(UsdtDepositNetwork.POLYGON, "1")).thenReturn(Result.failure(error)) + val model = UsdtDepositViewModel(repo) + model.selectNetwork(UsdtDepositNetwork.POLYGON) + model.prepare("1").join() + assertEquals(R.string.usdt__deposit_amount_out_of_range, model.state.value.error) + assertEquals(error, model.state.value.amountLimits) + model.clearAmountError() + assertNull(model.state.value.error) + assertNull(model.state.value.amountLimits) + assertEquals(UsdtDepositNetwork.POLYGON, model.state.value.network) + assertNull(model.state.value.address) + } + + @Test + fun `overlapping history pages replace stale deposits and retain their new offset`() = test { + whenever(repo.depositNetworks()).thenReturn(Result.success(persistentListOf())) + val first = UsdtDeposit("first", "tron", "USDT", 100u, "tx1", "held", null, null) + val second = first.copy(id = "second", sourceTx = "tx2") + val updated = second.copy(status = "completed") + whenever(repo.depositHistory(0u)).thenReturn(Result.success(UsdtDepositPage(listOf(first, second), 50u))) + whenever(repo.depositHistory(50u)).thenReturn(Result.success(UsdtDepositPage(listOf(updated), null))) + whenever(repo.depositDetail("second", 50u)).thenReturn(Result.success(UsdtDepositDetail(updated, null))) + val model = UsdtDepositViewModel(repo) + model.history().join() + model.history(50u).join() + assertEquals(listOf(first, updated), model.state.value.deposits) + assertNull(model.state.value.nextOffset) + model.detail("second") + assertEquals(50u, model.state.value.offset) + assertEquals(updated, model.state.value.detail?.deposit) + } + + @Test + fun `linked order status and error supersede deposit state together`() { + val deposit = UsdtDeposit("deposit", "tron", "USDT", 100u, "tx", "held", "standing_route_unavailable", null) + val completed = UsdtDepositOrder("completed", 100u, 90u, "destination-tx", null, null) + val cases = listOf( + Triple(completed, R.string.usdt__confirmed, null), + Triple(completed.copy(status = "refunded"), R.string.usdt__deposit_refunded, null), + Triple(null, R.string.usdt__deposit_needs_attention, deposit.code), + Triple(completed.copy(status = "unknown"), R.string.usdt__deposit_needs_attention, null), + Triple(completed.copy(status = "pending"), R.string.usdt__pending, null), + Triple(completed.copy(status = "processing"), R.string.usdt__pending, null), + Triple(completed.copy(status = "refund_requested"), R.string.usdt__deposit_refunding, null), + Triple( + completed.copy(status = "failed", code = "order_error"), + R.string.usdt__deposit_needs_attention, + "order_error" + ), + ) + cases.forEach { (order, expectedStatus, expectedCode) -> + val detail = UsdtDepositDetail(deposit, order) + assertEquals(expectedStatus, detail.statusResource()) + assertEquals(expectedCode, detail.statusCode) + } + } + + @Test + fun `deposit source names resolve to every supported network`() { + UsdtDepositNetwork.entries.forEach { network -> + assertEquals(network, network.name.lowercase().depositNetwork()) + } + assertNull("unsupported".depositNetwork()) + } + + @Test + fun `receive request locks network and navigation until cancellation`() = test { + whenever(repo.depositNetworks()).thenReturn(Result.success(persistentListOf(UsdtDepositNetwork.TRON))) + val result = CompletableDeferred>() + whenever(repo.prepareDeposit(UsdtDepositNetwork.TRON, "100")).doSuspendableAnswer { result.await() } + val model = UsdtDepositViewModel(repo) + model.selectNetwork(UsdtDepositNetwork.TRON) + val request = model.prepare("100") + assertTrue(model.state.value.busy) + model.selectNetwork(UsdtDepositNetwork.ETHEREUM) + model.prepare("100").join() + assertEquals(UsdtDepositNetwork.TRON, model.state.value.network) + assertTrue(model.back()) + verify(repo, times(1)).prepareDeposit(UsdtDepositNetwork.TRON, "100") + request.cancelAndJoin() + assertFalse(model.state.value.busy) + assertNull(model.state.value.address) + assertNull(model.state.value.error) + assertFalse(model.back()) + } + + @Test + fun `provider refund acknowledgment stays a request and keeps history intact`() = test { + whenever(repo.depositNetworks()).thenReturn(Result.success(persistentListOf())) + whenever(repo.depositHistory(50u)).thenReturn(Result.success(UsdtDepositPage(emptyList(), null))) + whenever(repo.refundDeposit("deposit", 50u, "source-address", UsdtDepositNetwork.TRON)) + .thenReturn(Result.success(Unit)) + val deposit = UsdtDeposit("deposit", "tron", "USDT", 100u, "source-tx", "held", null, null) + whenever(repo.depositDetail("deposit", 50u)).thenReturn(Result.success(UsdtDepositDetail(deposit, null))) + val model = UsdtDepositViewModel(repo) + model.history(50u).join() + model.detail("deposit") + model.refund("deposit", 50u, "source-address", UsdtDepositNetwork.TRON).join() + assertEquals(50u, model.state.value.offset) + assertTrue(model.state.value.history) + assertEquals(R.string.usdt__deposit_refund_requested, model.state.value.message) + assertEquals("refund_requested", model.state.value.detail?.deposit?.status) + model.refund("deposit", 50u, "source-address", UsdtDepositNetwork.TRON).join() + verify(repo, times(1)).refundDeposit("deposit", 50u, "source-address", UsdtDepositNetwork.TRON) + assertFalse(model.state.value.busy) + assertTrue(model.back()) + assertTrue(model.back()) + assertFalse(model.state.value.history) + } +} diff --git a/app/src/test/java/to/bitkit/ui/screens/wallets/usdt/UsdtViewModelTest.kt b/app/src/test/java/to/bitkit/ui/screens/wallets/usdt/UsdtViewModelTest.kt new file mode 100644 index 0000000000..e3cfec247f --- /dev/null +++ b/app/src/test/java/to/bitkit/ui/screens/wallets/usdt/UsdtViewModelTest.kt @@ -0,0 +1,220 @@ +package to.bitkit.ui.screens.wallets.usdt + +import com.synonym.bitkitcore.UsdtDestination +import com.synonym.bitkitcore.UsdtException +import com.synonym.bitkitcore.UsdtPaymentRequest +import com.synonym.bitkitcore.UsdtQuote +import com.synonym.bitkitcore.UsdtTransfer +import kotlinx.coroutines.CancellationException +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.flow +import kotlinx.coroutines.launch +import org.junit.Test +import org.mockito.Mockito +import org.mockito.kotlin.any +import org.mockito.kotlin.mock +import org.mockito.kotlin.never +import org.mockito.kotlin.times +import org.mockito.kotlin.verify +import org.mockito.kotlin.whenever +import to.bitkit.R +import to.bitkit.data.SettingsData +import to.bitkit.data.SettingsStore +import to.bitkit.repositories.UsdtRepo +import to.bitkit.repositories.UsdtWalletState +import to.bitkit.repositories.parseUsdtPaymentRequest +import to.bitkit.test.BaseUnitTest +import to.bitkit.viewmodels.SanityWarning +import java.io.IOException +import kotlin.test.assertEquals +import kotlin.test.assertFailsWith +import kotlin.test.assertFalse +import kotlin.test.assertNull +import kotlin.test.assertTrue + +class UsdtViewModelTest : BaseUnitTest() { + private val repo: UsdtRepo = mock() + private val settingsStore: SettingsStore = mock() + private val settings = MutableStateFlow(SettingsData(isPinEnabled = true, isPinForPaymentsEnabled = true)) + private val quote = UsdtQuote( + id = "payment", + recipient = "0x1111111111111111111111111111111111111111", + destination = UsdtDestination.ARBITRUM, + bridgeProvider = null, + amount = 1_000_000u, + receivedAmount = 1_000_000u, + maximumFee = 20u, + expiresAt = 100u, + ) + + @Test + fun `recipient errors prevent advancing until a valid address is parsed`() = test { + val viewModel = createViewModel() + val parser = Mockito.mockStatic(Class.forName("to.bitkit.repositories.UsdtRepoKt")) + parser.`when`> { parseUsdtPaymentRequest("invalid", UsdtDestination.ARBITRUM) } + .thenReturn(Result.failure(UsdtException.InvalidAddress())) + for (destination in listOf(UsdtDestination.ARBITRUM, UsdtDestination.POLYGON)) { + parser.`when`> { parseUsdtPaymentRequest("valid request", destination) } + .thenReturn(Result.success(UsdtPaymentRequest(quote.recipient, 1_500_000u, 42161u))) + } + try { + var request: UsdtPaymentRequest? = null + viewModel.validateRecipient("invalid", UsdtDestination.ARBITRUM) { request = it } + assertNull(request) + assertEquals(R.string.usdt__error_address, viewModel.state.value.error) + viewModel.validateRecipient("valid request", UsdtDestination.POLYGON) { request = it } + assertNull(request) + assertEquals(R.string.usdt__error_address, viewModel.state.value.error) + viewModel.validateRecipient("valid request", UsdtDestination.ARBITRUM) { request = it } + assertEquals(quote.recipient, request?.recipient) + assertEquals(1_500_000uL, request?.amount) + verify(repo, never()).quote(any(), any(), any(), any()) + verify(repo, never()).send(any()) + assertNull(viewModel.state.value.error) + } finally { parser.close() } + } + + @Test + fun `payment authentication cannot be skipped or reused after cancellation`() = test { + val viewModel = createViewModel() + viewModel.quote(quote.recipient, "1", quote.destination).join() + viewModel.confirm().join() + assertTrue(viewModel.state.value.authenticationRequired) + verify(repo, never()).send(any()) + + viewModel.cancelAuthentication() + viewModel.authenticationVerified() + verify(repo, never()).send(any()) + + viewModel.confirm().join() + viewModel.authenticationVerified() + viewModel.authenticationVerified() + viewModel.confirm().join() + verify(repo, times(1)).send(quote) + assertTrue(viewModel.state.value.submitted) + assertTrue(viewModel.state.value.busy) + viewModel.waitForTransfer() + assertFalse(viewModel.state.value.busy) + } + + @Test + fun `failed submission clears the quote and never reports success`() = test { + val viewModel = createViewModel() + settings.value = settings.value.copy(isPinForPaymentsEnabled = false) + whenever(repo.send(quote)).thenReturn(Result.failure(UsdtException.QuoteExpired())) + viewModel.quote(quote.recipient, "1", quote.destination).join() + viewModel.confirm().join() + assertFalse(viewModel.state.value.authenticationRequired) + assertFalse(viewModel.state.value.submitted) + assertFalse(viewModel.state.value.busy) + assertNull(viewModel.state.value.quote) + assertEquals(R.string.usdt__error_expired, viewModel.state.value.error) + viewModel.confirm().join() + verify(repo, times(1)).send(quote) + } + + @Test + fun `amount warnings require acknowledgment before payment authentication`() = test { + val viewModel = createViewModel() + val large = quote.copy(amount = 200_000_000u, receivedAmount = 200_000_000u) + settings.value = settings.value.copy(enableSendAmountWarning = true) + whenever(repo.quote(any(), any(), any(), any())).thenReturn(Result.success(large)) + viewModel.quote(large.recipient, "200", large.destination).join() + viewModel.confirm().join() + assertEquals(SanityWarning.VALUE_OVER_100_USD, viewModel.state.value.warning) + assertFalse(viewModel.state.value.authenticationRequired) + verify(repo, never()).send(any()) + viewModel.acceptWarning() + assertNull(viewModel.state.value.warning) + assertTrue(viewModel.state.value.authenticationRequired) + viewModel.edit() + assertTrue(viewModel.state.value.confirmedWarnings.isEmpty()) + } + + @Test + fun `editing while settings load cannot authorize a replacement quote`() = test { + val viewModel = createViewModel() + val delayed = kotlinx.coroutines.flow.MutableSharedFlow() + whenever(settingsStore.data).thenReturn(delayed) + viewModel.quote(quote.recipient, "1", quote.destination).join() + val confirmation = viewModel.confirm() + assertTrue(viewModel.state.value.busy) + viewModel.edit() + val replacement = quote.copy(id = "replacement", amount = 2_000_000u) + whenever(repo.quote(any(), any(), any(), any())).thenReturn(Result.success(replacement)) + viewModel.quote(replacement.recipient, "2", replacement.destination).join() + delayed.emit(SettingsData(isPinEnabled = false)) + confirmation.join() + verify(repo, never()).send(any()) + assertEquals("replacement", viewModel.state.value.quote?.id) + } + + @Test + fun `settings failures keep balances private and block confirmation until settings recover`() = test { + var failing = true + val viewModel = createViewModel( + flow { + if (failing) throw IOException("settings unavailable") + emit(settings.value) + } + ) + val collector = backgroundScope.launch { viewModel.settings.collect {} } + viewModel.quote(quote.recipient, "1", quote.destination).join() + viewModel.confirm().join() + assertTrue(viewModel.settings.value.hideBalance) + assertEquals(R.string.usdt__error_storage, viewModel.state.value.error) + assertFalse(viewModel.state.value.busy) + assertFalse(viewModel.state.value.authenticationRequired) + verify(repo, never()).send(any()) + + failing = false + viewModel.confirm().join() + assertNull(viewModel.state.value.error) + assertTrue(viewModel.state.value.authenticationRequired) + verify(repo, never()).send(any()) + collector.cancel() + } + + @Test + fun `payment settings never authorize a refund on read failure or cancellation`() = test { + val viewModel = createViewModel() + whenever(settingsStore.data).thenReturn(flow { throw IOException("settings unavailable") }) + var refundAuthorized = false + viewModel.readPaymentSettings { refundAuthorized = true } + assertFalse(refundAuthorized) + assertEquals(R.string.usdt__error_storage, viewModel.state.value.error) + + viewModel.edit() + whenever(settingsStore.data).thenReturn(flow { throw CancellationException() }) + assertFailsWith { + viewModel.readPaymentSettings { refundAuthorized = true } + } + assertFalse(refundAuthorized) + assertNull(viewModel.state.value.error) + } + + @Test + fun `cancelled execution wait keeps the submitted payment and releases the swipe`() = test { + val viewModel = createViewModel() + settings.value = settings.value.copy(isPinForPaymentsEnabled = false) + viewModel.quote(quote.recipient, "1", quote.destination).join() + viewModel.confirm().join() + whenever(repo.waitForTransfer(quote.id)).thenThrow(CancellationException()) + assertFailsWith { viewModel.waitForTransfer() } + assertTrue(viewModel.state.value.submitted) + assertFalse(viewModel.state.value.busy) + assertEquals(quote, viewModel.state.value.quote) + assertNull(viewModel.state.value.error) + } + + private suspend fun createViewModel(settingsFlow: Flow = settings): UsdtViewModel { + whenever(repo.state).thenReturn(MutableStateFlow(UsdtWalletState())) + whenever(settingsStore.data).thenReturn(settingsFlow) + whenever(repo.quote(any(), any(), any(), any())).thenReturn(Result.success(quote)) + whenever(repo.send(quote)).thenReturn(Result.success(mock())) + whenever(repo.refresh(false)).thenReturn(Result.success(Unit)) + whenever(repo.waitForTransfer(quote.id)).thenReturn(Result.success(Unit)) + return UsdtViewModel(repo, settingsStore) + } +} diff --git a/app/src/test/java/to/bitkit/usecases/WipeWalletUseCaseTest.kt b/app/src/test/java/to/bitkit/usecases/WipeWalletUseCaseTest.kt index fc7f2d144b..8063b14a52 100644 --- a/app/src/test/java/to/bitkit/usecases/WipeWalletUseCaseTest.kt +++ b/app/src/test/java/to/bitkit/usecases/WipeWalletUseCaseTest.kt @@ -31,6 +31,7 @@ import to.bitkit.repositories.LightningState import to.bitkit.repositories.PrivatePaykitAddressReservationRepo import to.bitkit.repositories.PrivatePaykitRepo import to.bitkit.repositories.PubkyRepo +import to.bitkit.repositories.UsdtRepo import to.bitkit.repositories.WatchOnlyAccountRepo import to.bitkit.services.CoreService import to.bitkit.services.MigrationService @@ -47,6 +48,7 @@ class WipeWalletUseCaseTest : BaseUnitTest() { private val backupRepo = mock() private val keychain = mock() private val coreService = mock() + private val usdtRepo = mock() private val db = mock() private val settingsStore = mock() private val cacheStore = mock() @@ -72,6 +74,10 @@ class WipeWalletUseCaseTest : BaseUnitTest() { @Before fun setUp() { whenever { lightningRepo.stop() }.thenReturn(Result.success(Unit)) + whenever { usdtRepo.wipe(any()) }.doSuspendableAnswer { + it.getArgument Unit>(0).invoke() + Result.success(Unit) + } whenever { lightningRepo.wipeStorage(0) }.thenReturn(Result.success(Unit)) whenever(lightningRepo.lightningState).thenReturn(MutableStateFlow(LightningState())) whenever { pubkyRepo.removeBitkitPaymentEndpoints() }.thenReturn(Result.success(Unit)) @@ -85,6 +91,7 @@ class WipeWalletUseCaseTest : BaseUnitTest() { backupRepo = backupRepo, keychain = keychain, coreService = coreService, + usdtRepo = usdtRepo, db = db, settingsStore = settingsStore, cacheStore = cacheStore, @@ -115,6 +122,7 @@ class WipeWalletUseCaseTest : BaseUnitTest() { backupRepo, keychain, coreService, + usdtRepo, db, settingsStore, cacheStore, @@ -141,6 +149,7 @@ class WipeWalletUseCaseTest : BaseUnitTest() { inOrder.verify(migrationService).cleanupAfterMigration() inOrder.verify(privatePaykitAddressReservationRepo).clear() inOrder.verify(pubkyRepo).wipeLocalState() + inOrder.verify(usdtRepo).wipe(any()) inOrder.verify(keychain).wipe() inOrder.verify(coreService).wipeData() inOrder.verify(db).clearAllTables() diff --git a/app/src/test/java/to/bitkit/viewmodels/AppViewModelSendFlowTest.kt b/app/src/test/java/to/bitkit/viewmodels/AppViewModelSendFlowTest.kt index 957c2387b5..fea6b05ad2 100644 --- a/app/src/test/java/to/bitkit/viewmodels/AppViewModelSendFlowTest.kt +++ b/app/src/test/java/to/bitkit/viewmodels/AppViewModelSendFlowTest.kt @@ -63,6 +63,7 @@ import org.mockito.kotlin.any import org.mockito.kotlin.anyOrNull import org.mockito.kotlin.argumentCaptor import org.mockito.kotlin.atLeast +import org.mockito.kotlin.atLeastOnce import org.mockito.kotlin.check import org.mockito.kotlin.clearInvocations import org.mockito.kotlin.doReturn @@ -93,6 +94,7 @@ import to.bitkit.data.keychain.Keychain import to.bitkit.domain.commands.NotifyChannelReadyHandler import to.bitkit.domain.commands.NotifyPaymentReceived import to.bitkit.domain.commands.NotifyPaymentReceivedHandler +import to.bitkit.env.Env import to.bitkit.ext.callbackAmountMsats import to.bitkit.ext.fromHex import to.bitkit.ext.runSuspendCatching @@ -107,6 +109,9 @@ import to.bitkit.models.NewTransactionSheetDetails import to.bitkit.models.NewTransactionSheetDirection import to.bitkit.models.NewTransactionSheetType import to.bitkit.models.NodeLifecycleState +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset +import to.bitkit.models.PaykitRequestPricing import to.bitkit.models.PubkyProfile import to.bitkit.models.SamRockPaymentMethod import to.bitkit.models.SamRockSetupRequest @@ -124,6 +129,7 @@ import to.bitkit.repositories.ConnectivityRepo import to.bitkit.repositories.ConnectivityState import to.bitkit.repositories.ContactPaymentSettingsRepo import to.bitkit.repositories.CurrencyRepo +import to.bitkit.repositories.Endpoint import to.bitkit.repositories.HealthRepo import to.bitkit.repositories.HwWalletRepo import to.bitkit.repositories.IncomingPaykitPaymentRequestFailureReason @@ -256,6 +262,9 @@ class AppViewModelSendFlowTest : BaseUnitTest() { private val paykitPaymentRequestRepo = mock() private val paykitPaymentProofRepo = mock() private val paykitPaymentRequestDiagnostics = mock() + private val usdtRepo = mock() + private val usdtState = MutableStateFlow(to.bitkit.repositories.UsdtWalletState(balance = 1_000_000u)) + private val paykitUsdtPayments = mock() private val samRockRepo = mock() private val widgetsRepo = mock() private val formatMoneyValue = mock() @@ -322,6 +331,25 @@ class AppViewModelSendFlowTest : BaseUnitTest() { App.currentActivity = null } + @Test + fun `foreground polling reconciles configured USDT payment proofs`() = test { + enablePaykitUi() + pubkyPublicKey.value = testPublicKey + whenever(paykitPaymentRequestRepo.refresh()).thenReturn(Result.success(Unit)) + clearInvocations(paykitUsdtPayments) + sut.startPaykitPaymentRequestPolling() + try { + runCurrent() + if (Env.isUsdtEnabled) { + verify(paykitUsdtPayments, atLeastOnce()).reconcile() + } else { + verify(paykitUsdtPayments, never()).reconcile() + } + } finally { + sut.stopPaykitPaymentRequestPolling() + } + } + @Test fun `current toast is hidden only when dev mode and disable all toasts are both on`() = test { val toast = Toast(Toast.ToastType.SUCCESS, "Toast", null, true, Toast.VISIBILITY_TIME_DEFAULT, null) @@ -389,6 +417,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { @Suppress("LongMethod") private fun stubRepositories() { + whenever(currencyRepo.currencyState).thenReturn(MutableStateFlow(to.bitkit.repositories.CurrencyState())) whenever(context.getString(any())).thenReturn("") whenever(context.getSystemService(Context.CLIPBOARD_SERVICE)).thenReturn(clipboardManager) whenever(connectivityRepo.isOnline).thenReturn(connectivityState) @@ -446,6 +475,14 @@ class AppViewModelSendFlowTest : BaseUnitTest() { .thenReturn(Result.success(Unit)) whenever(pubkyRepo.contactsLoadVersion).thenReturn(pubkyContactsLoadVersion) whenever(pubkyRepo.contactsLoadCompletionVersion).thenReturn(pubkyContactsLoadCompletionVersion) + whenever(usdtRepo.state).thenReturn(usdtState) + whenever { usdtRepo.refresh(any(), any()) }.thenReturn(Result.success(Unit)) + whenever { paykitUsdtPayments.reconcile() }.thenReturn(Result.success(Unit)) + whenever(paykitUsdtPayments.receipts).thenReturn(MutableStateFlow(emptyList())) + whenever { paykitUsdtPayments.send(any(), any()) }.doSuspendableAnswer { + val beforeSend = it.getArgument Unit>(1) + runCatching { beforeSend() } + } whenever(paykitPaymentRequestRepo.pendingRequests).thenReturn(pendingPaykitPaymentRequests) whenever(paykitPaymentRequestRepo.paymentRequestHistory).thenReturn(paykitPaymentRequestHistory) whenever(paykitPaymentRequestRepo.subscriptions).thenReturn(paykitSubscriptions) @@ -596,6 +633,8 @@ class AppViewModelSendFlowTest : BaseUnitTest() { paykitPaymentProofRepo = paykitPaymentProofRepo, paykitPaymentRequestDiagnostics = paykitPaymentRequestDiagnostics, refreshContactPaykitLink = refreshContactPaykitLink, + usdtRepo = usdtRepo, + paykitUsdtPayments = paykitUsdtPayments, samRockRepo = samRockRepo, appUpdateSheet = mock(), backupSheet = mock(), @@ -1099,15 +1138,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { verify(paykitPaymentProofRepo, never()).reconcile() verify(paykitPaymentRequestRepo, never()).refreshEligibleTargets(any(), eq(true)) - repeat(5) { - clearInvocations(paykitPaymentRequestRepo) - advanceTimeBy(10.seconds.inWholeMilliseconds - 1) - runCurrent() - verify(paykitPaymentRequestRepo, never()).refresh(any()) - advanceTimeBy(1) - runCurrent() - verify(paykitPaymentRequestRepo).refresh(any()) - } + repeat(5) { verifyPaymentRequestPollingInterval() } verify(privatePaykitRepo).refreshKnownSavedContactEndpoints(any(), any()) verify(paykitPaymentProofRepo).reconcile() verify(paykitPaymentRequestRepo).refreshEligibleTargets(any(), eq(true)) @@ -1177,7 +1208,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { ), ) stubLightningScan(bolt11 = bolt11, amountSats = 0u) - whenever(lightningRepo.canSend(request.amountSats)).thenReturn(true) + whenever(lightningRepo.canSend(request.amount.atomic)).thenReturn(true) balanceState.value = BalanceState(maxSendLightningSats = 100_000u) pendingPaykitPaymentRequests.value = listOf(request) isPaykitEnabled.value = true @@ -1683,8 +1714,8 @@ class AppViewModelSendFlowTest : BaseUnitTest() { allowPreparation = false Result.success(PublicPaykitPaymentResult.Opened(bolt11, privatePaymentContext(7uL))) } - stubLightningScan(bolt11, request.amountSats) - whenever(lightningRepo.canSend(request.amountSats)).thenReturn(false) + stubLightningScan(bolt11, request.amount.atomic) + whenever(lightningRepo.canSend(request.amount.atomic)).thenReturn(false) whenever(formatMoneyValue(any())).thenReturn("2,500 sats") pendingPaykitPaymentRequests.value = listOf(request) runCurrent() @@ -1700,7 +1731,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { verify(paykitPaymentRequestRepo, never()).accept(any()) verify(privatePaykitRepo, never()).consumePrivatePaymentList(any(), any()) - whenever(lightningRepo.canSend(request.amountSats)).thenReturn(true) + whenever(lightningRepo.canSend(request.amount.atomic)).thenReturn(true) balanceState.value = BalanceState(maxSendLightningSats = 100_000u) allowPreparation = true sut.openIncomingPaymentRequest(request.id) @@ -2507,7 +2538,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { scanStarted.complete(Unit) awaitCancellation() } - stubLightningScan(bolt11 = queuedBolt11, amountSats = queuedRequest.amountSats) + stubLightningScan(bolt11 = queuedBolt11, amountSats = queuedRequest.amount.atomic) balanceState.value = BalanceState(maxSendLightningSats = 100_000u) pendingPaykitPaymentRequests.value = listOf(expiredRequest, queuedRequest) enablePaykitUi() @@ -2552,7 +2583,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { "The payment request has expired." ) stubOpenedPaymentRequest(request, bolt11) - stubLightningScan(bolt11 = bolt11, amountSats = request.amountSats) + stubLightningScan(bolt11 = bolt11, amountSats = request.amount.atomic) balanceState.value = BalanceState(maxSendLightningSats = 100_000u) pendingPaykitPaymentRequests.value = listOf(request) enablePaykitUi() @@ -3000,7 +3031,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { holdRequestScan.await() Scanner.Lightning(lightningInvoice(requestInvoice, 0u)) } - stubLightningScan(bolt11 = replacementInvoice, amountSats = request.amountSats) + stubLightningScan(bolt11 = replacementInvoice, amountSats = request.amount.atomic) balanceState.value = BalanceState(maxSendLightningSats = 100_000u) pendingPaykitPaymentRequests.value = listOf(request) enablePaykitUi() @@ -3045,7 +3076,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { } Scanner.Lightning(lightningInvoice(bolt11, 0u)) } - whenever(lightningRepo.canSend(request.amountSats)).thenReturn(true) + whenever(lightningRepo.canSend(request.amount.atomic)).thenReturn(true) balanceState.value = BalanceState(maxSendLightningSats = 100_000u) sut.onScanResult(bolt11) @@ -3076,7 +3107,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { finishScan.await() Scanner.Lightning(lightningInvoice(bolt11, 0u)) } - whenever(lightningRepo.canSend(request.amountSats)).thenReturn(true) + whenever(lightningRepo.canSend(request.amount.atomic)).thenReturn(true) balanceState.value = BalanceState(maxSendLightningSats = 100_000u) sut.openContactPayment( @@ -4753,7 +4784,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { val bolt11 = "lnbcrt1afterrejectedcontact" balanceState.value = BalanceState(maxSendLightningSats = 100_000u) stubLightningScan(bolt11 = bolt11, amountSats = 0u) - whenever(lightningRepo.canSend(request.amountSats)).thenReturn(true) + whenever(lightningRepo.canSend(request.amount.atomic)).thenReturn(true) stubOpenedPaymentRequest(request, bolt11) whenever(paykitPaymentRequestRepo.refresh(any())).thenReturn(Result.success(Unit)) pendingPaykitPaymentRequests.value = listOf(request) @@ -4763,7 +4794,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { assertEquals(Sheet.Send(SendRoute.Confirm), sut.currentSheet.value) assertEquals(request, activeContactPaymentContext()?.incomingPaymentRequest) - assertEquals(request.amountSats, sut.sendUiState.value.amount) + assertEquals(request.amount.atomic, sut.sendUiState.value.amount) } @Test @@ -7534,8 +7565,8 @@ class AppViewModelSendFlowTest : BaseUnitTest() { pubkyPublicKey.value = testPublicKey balanceState.value = BalanceState(maxSendLightningSats = 100_000u) stubLightningScan(bolt11 = bolt11, amountSats = 0u) - whenever(lightningRepo.canSend(request.amountSats)).thenReturn(true) - whenever(lightningRepo.estimateRoutingFeesForAmount(bolt11, request.amountSats)) + whenever(lightningRepo.canSend(request.amount.atomic)).thenReturn(true) + whenever(lightningRepo.estimateRoutingFeesForAmount(bolt11, request.amount.atomic)) .thenReturn(Result.success(4uL)) val privateContext = stubOpenedPaymentRequest(request, bolt11) whenever(paykitPaymentRequestRepo.refresh(any())).thenReturn(Result.success(Unit)) @@ -7547,7 +7578,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { sut.stopPaykitPaymentRequestPolling() assertEquals(Sheet.Send(SendRoute.Confirm), sut.currentSheet.value) - assertEquals(request.amountSats, sut.sendUiState.value.amount) + assertEquals(request.amount.atomic, sut.sendUiState.value.amount) assertEquals(4L, sut.sendUiState.value.lightningFeeSats) assertTrue(sut.sendUiState.value.isAmountInputValid) assertTrue(sut.sendUiState.value.isPaymentRequest) @@ -7607,7 +7638,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { runCurrent() verify(coreService).decode(REGTEST_ADDRESS) - assertEquals(request.amountSats, sut.sendUiState.value.amount) + assertEquals(request.amount.atomic, sut.sendUiState.value.amount) assertTrue(sut.sendUiState.value.isAmountInputValid) assertTrue(sut.sendUiState.value.isPaymentRequest) assertEquals(SendMethod.ONCHAIN, sut.sendUiState.value.payMethod) @@ -7773,7 +7804,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { val request = paymentRequest().copy(counterparty = "pubkyrecipient") val target = PaykitPaymentRequestTarget(request.counterparty) val draft = PaykitPaymentRequestDraft( - amountSats = request.amountSats, + amount = PaykitAmount(PaykitAsset.BTC, request.amount.atomic), note = "Lunch", expiresAt = Clock.System.now() + 60.seconds, ) @@ -7801,7 +7832,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { val request = paymentRequest().copy(counterparty = "pubkyrecipient") val target = PaykitPaymentRequestTarget(request.counterparty) val draft = PaykitPaymentRequestDraft( - amountSats = request.amountSats, + amount = PaykitAmount(PaykitAsset.BTC, request.amount.atomic), note = "Lunch", expiresAt = Clock.System.now() + 60.seconds, ) @@ -7830,7 +7861,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { val request = paymentRequest().copy(counterparty = "pubkyrecipient") val target = PaykitPaymentRequestTarget(request.counterparty) val draft = PaykitPaymentRequestDraft( - amountSats = request.amountSats, + amount = PaykitAmount(PaykitAsset.BTC, request.amount.atomic), note = "Lunch", expiresAt = Clock.System.now() + 60.seconds, ) @@ -7902,12 +7933,12 @@ class AppViewModelSendFlowTest : BaseUnitTest() { whenever(paykitPaymentRequestRepo.accept(request)).thenReturn(Result.success(Unit)) whenever(privatePaykitRepo.consumePrivatePaymentList(testPublicKey, privateContext)) .thenReturn(Result.success(Unit)) - stubSuccessfulOnchainSend(address, request.amountSats) + stubSuccessfulOnchainSend(address, request.amount.atomic) setActiveContactPaymentContext(testPublicKey, privateContext, request) setSendState( SendUiState( address = address, - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -8020,12 +8051,12 @@ class AppViewModelSendFlowTest : BaseUnitTest() { whenever(paykitPaymentRequestRepo.accept(request)).thenReturn(Result.success(Unit)) whenever(privatePaykitRepo.consumePrivatePaymentList(testPublicKey, privateContext)) .thenReturn(Result.success(Unit)) - stubSuccessfulOnchainSend(address, request.amountSats) + stubSuccessfulOnchainSend(address, request.amount.atomic) setActiveContactPaymentContext(testPublicKey, privateContext, request) setSendState( SendUiState( address = address, - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -8058,12 +8089,12 @@ class AppViewModelSendFlowTest : BaseUnitTest() { whenever(paykitPaymentRequestRepo.accept(request)).thenReturn(Result.success(Unit)) whenever(privatePaykitRepo.consumePrivatePaymentList(testPublicKey, privateContext)) .thenReturn(Result.success(Unit)) - stubSuccessfulOnchainSend(address, request.amountSats) + stubSuccessfulOnchainSend(address, request.amount.atomic) setActiveContactPaymentContext(testPublicKey, privateContext, request) setSendState( SendUiState( address = address, - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -8127,14 +8158,14 @@ class AppViewModelSendFlowTest : BaseUnitTest() { .thenReturn(Result.success(Unit)) stubOnchainSend( address = "bcrt1quncertainwithoutproof", - sats = request.amountSats, + sats = request.amount.atomic, result = Result.failure(IllegalStateException("outcome unknown")), ) setActiveContactPaymentContext(testPublicKey, privateContext, request) setSendState( SendUiState( address = "bcrt1quncertainwithoutproof", - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -8174,7 +8205,9 @@ class AppViewModelSendFlowTest : BaseUnitTest() { ) ) .doSuspendableAnswer { - setSendState(sut.sendUiState.value.copy(decodedInvoice = lightningInvoice(bolt11, request.amountSats))) + setSendState( + sut.sendUiState.value.copy(decodedInvoice = lightningInvoice(bolt11, request.amount.atomic)) + ) Result.success(Unit) } whenever { paykitPaymentProofRepo.associateLightningPayment(any(), any(), any(), eq("bitkit")) } @@ -8187,7 +8220,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = bolt11, - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.LIGHTNING, isPaymentRequest = true, ), @@ -8227,7 +8260,9 @@ class AppViewModelSendFlowTest : BaseUnitTest() { PaykitPaymentProofKind.Lightning ), ).doSuspendableAnswer { - setSendState(sut.sendUiState.value.copy(decodedInvoice = lightningInvoice(bolt11, request.amountSats))) + setSendState( + sut.sendUiState.value.copy(decodedInvoice = lightningInvoice(bolt11, request.amount.atomic)) + ) if (preparationSucceeds) { Result.success(Unit) } else { @@ -8254,7 +8289,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = bolt11, - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.LIGHTNING, isPaymentRequest = true, ), @@ -8292,7 +8327,9 @@ class AppViewModelSendFlowTest : BaseUnitTest() { ) ) .doSuspendableAnswer { - setSendState(sut.sendUiState.value.copy(decodedInvoice = lightningInvoice(bolt11, request.amountSats))) + setSendState( + sut.sendUiState.value.copy(decodedInvoice = lightningInvoice(bolt11, request.amount.atomic)) + ) Result.success(Unit) } whenever(paykitPaymentRequestRepo.accept(request)).thenReturn(Result.success(Unit)) @@ -8304,7 +8341,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = bolt11, - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.LIGHTNING, isPaymentRequest = true, ), @@ -8349,7 +8386,9 @@ class AppViewModelSendFlowTest : BaseUnitTest() { ) ) .doSuspendableAnswer { - setSendState(sut.sendUiState.value.copy(decodedInvoice = lightningInvoice(bolt11, request.amountSats))) + setSendState( + sut.sendUiState.value.copy(decodedInvoice = lightningInvoice(bolt11, request.amount.atomic)) + ) Result.success(Unit) } whenever(paykitPaymentRequestRepo.accept(request)).thenReturn(Result.success(Unit)) @@ -8362,7 +8401,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = bolt11, - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.LIGHTNING, isPaymentRequest = true, ), @@ -8412,7 +8451,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { whenever(paykitPaymentRequestRepo.accept(request)).thenReturn(Result.success(Unit)) whenever(privatePaykitRepo.consumePrivatePaymentList(testPublicKey, privateContext)) .thenReturn(Result.success(Unit)) - whenever(lightningRepo.fetchLnurlInvoice(lnurl, lnurl.callbackAmountMsats(request.amountSats), null)) + whenever(lightningRepo.fetchLnurlInvoice(lnurl, lnurl.callbackAmountMsats(request.amount.atomic), null)) .thenReturn(Result.failure(IllegalStateException("callback failed"))) sut.showSheet(Sheet.Send(SendRoute.Confirm)) advanceUntilIdle() @@ -8420,7 +8459,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = lnurl.uri, - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.LIGHTNING, lnurl = LnurlParams.LnurlPay(lnurl), isPaymentRequest = true, @@ -8439,7 +8478,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { verify(lightningRepo, never()).payInvoice(any(), anyOrNull()) inOrder(paykitPaymentRequestRepo, lightningRepo).apply { verify(paykitPaymentRequestRepo).accept(request) - verify(lightningRepo).fetchLnurlInvoice(lnurl, lnurl.callbackAmountMsats(request.amountSats), null) + verify(lightningRepo).fetchLnurlInvoice(lnurl, lnurl.callbackAmountMsats(request.amount.atomic), null) } verify(toastManager, never()).enqueue(any()) @@ -8477,7 +8516,9 @@ class AppViewModelSendFlowTest : BaseUnitTest() { ) ) .doSuspendableAnswer { - setSendState(sut.sendUiState.value.copy(decodedInvoice = lightningInvoice(bolt11, request.amountSats))) + setSendState( + sut.sendUiState.value.copy(decodedInvoice = lightningInvoice(bolt11, request.amount.atomic)) + ) Result.success(Unit) } whenever(paykitPaymentRequestRepo.accept(request)).thenReturn(Result.success(Unit)) @@ -8489,7 +8530,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = bolt11, - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.LIGHTNING, isPaymentRequest = true, ), @@ -8499,7 +8540,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { sut.setSendEvent(SendEvent.PayConfirmed) advanceUntilIdle() - assertEquals(SendEffect.NavigateToPending(paymentHash, request.amountSats.toLong()), awaitItem()) + assertEquals(SendEffect.NavigateToPending(paymentHash, request.amount.atomic.toLong()), awaitItem()) } verify(pendingPaymentRepo).track(paymentHash) verify(paykitPaymentProofRepo, never()).failLightningPayment(any()) @@ -8526,7 +8567,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = bolt11, - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.LIGHTNING, isPaymentRequest = true, ), @@ -8555,7 +8596,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { .thenReturn(Result.failure(PaykitPaymentRequestError.OperationInProgress)) setActiveContactPaymentContext(testPublicKey, privateContext, request) setSendState( - SendUiState(address = "bcrt1qpaymentrequest", amount = request.amountSats, isPaymentRequest = true), + SendUiState(address = "bcrt1qpaymentrequest", amount = request.amount.atomic, isPaymentRequest = true), ) assertFalse(sut.prepareHardwareContactPayment(signedTx = hardwareSignedReceipt())) @@ -8585,7 +8626,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = "bcrt1qpaymentrequest", - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -8624,6 +8665,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { paykitPaymentProofRepo.markOnchainPaymentStarted( request, "bcrt1qpaymentrequest", + request.amount.atomic, "hardware-wallet", 7uL, hardwareSignedReceipt(), @@ -8636,7 +8678,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = "bcrt1qpaymentrequest", - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -8662,7 +8704,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = "bcrt1qpaymentrequest", - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -8813,7 +8855,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = "bcrt1qpaymentrequest", - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -8895,7 +8937,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = "bcrt1qpaymentrequest", - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -8924,7 +8966,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = "bcrt1qpaymentrequest", - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -9016,7 +9058,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = "bcrt1qpaymentrequest", - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -9059,7 +9101,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = "bcrt1qpaymentrequest", - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -9293,12 +9335,12 @@ class AppViewModelSendFlowTest : BaseUnitTest() { } whenever(privatePaykitRepo.consumePrivatePaymentList(testPublicKey, privateContext)) .thenReturn(Result.success(Unit)) - stubSuccessfulOnchainSend(address, request.amountSats) + stubSuccessfulOnchainSend(address, request.amount.atomic) setActiveContactPaymentContext(testPublicKey, privateContext, request) setSendState( SendUiState( address = address, - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -9581,8 +9623,11 @@ class AppViewModelSendFlowTest : BaseUnitTest() { @Test fun `subscription acceptance pays a due period materialized during acceptance`() = test { val subscription = subscriptionStartingAt(Clock.System.now() + 60.seconds) + val endpoint = Endpoint(MethodId.UsdtArbitrum, "0x1111111111111111111111111111111111111111", null, null, "") val dueRequest = paymentRequest().copy( paymentRequestId = subscription.paymentRequestId, + amount = PaykitAmount(PaykitAsset.USDT, 50_000uL), + acceptedPaymentEndpointIdentifiers = listOf(endpoint.methodId.rawValue), lifecycleState = PaymentRequestLifecycleState.ACTIVE_RECURRING, billingPeriod = PaykitBillingPeriod( startsAt = Clock.System.now(), @@ -9593,7 +9638,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { assertNull(subscription.paymentDueOnAcceptance(Clock.System.now())) whenever(paykitPaymentRequestRepo.accept(subscription)).thenReturn(Result.success(dueRequest)) whenever(privatePaykitRepo.beginPaymentRequestWaitingForUpdatedList(dueRequest)).thenReturn( - Result.success(PublicPaykitPaymentResult.WaitingForUpdatedPaymentList) + Result.success(PublicPaykitPaymentResult.Opened(endpoint.value, endpoints = listOf(endpoint))) ) sut.showSheet(Sheet.Subscription(SubscriptionRoute.Review(subscription.id))) advanceUntilIdle() @@ -9608,6 +9653,9 @@ class AppViewModelSendFlowTest : BaseUnitTest() { verify(privatePaykitRepo).beginPaymentRequestWaitingForUpdatedList(dueRequest) assertTrue(sut.currentSheet.value is Sheet.Send) assertTrue(sut.sendUiState.value.isInitialSubscriptionPayment) + assertTrue(sut.sendUiState.value.paykitUsesUsdt) + assertEquals(endpoint.value, sut.sendUiState.value.usdtRecipient) + assertEquals("0.05", sut.sendUiState.value.paykitAmount) assertEquals(dueRequest.id, sut.sendUiState.value.incomingPaymentRequestId) assertFalse(sut.isAcceptingSubscription.value) } @@ -9682,7 +9730,11 @@ class AppViewModelSendFlowTest : BaseUnitTest() { @Test fun `initial subscription retry keeps the send sheet presented`() = test { - val request = paymentRequest() + val endpoint = Endpoint(MethodId.UsdtArbitrum, "0x1111111111111111111111111111111111111111", null, null, "") + val request = paymentRequest().copy( + amount = PaykitAmount(PaykitAsset.USDT, 50_000uL), + acceptedPaymentEndpointIdentifiers = listOf(endpoint.methodId.rawValue), + ) enablePaykitUi() pubkyPublicKey.value = testPublicKey runCurrent() @@ -9693,7 +9745,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { Result.success(Unit) } whenever(privatePaykitRepo.beginPaymentRequestWaitingForUpdatedList(request)).thenReturn( - Result.success(PublicPaykitPaymentResult.WaitingForUpdatedPaymentList) + Result.success(PublicPaykitPaymentResult.Opened(endpoint.value, endpoints = listOf(endpoint))) ) val sendSheet = Sheet.Send( SendRoute.errorFromFailure( @@ -9723,6 +9775,9 @@ class AppViewModelSendFlowTest : BaseUnitTest() { verify(privatePaykitRepo).beginPaymentRequestWaitingForUpdatedList(request) assertTrue(sut.currentSheet.value is Sheet.Send) assertFalse(sut.isRetryingInitialSubscriptionPayment.value) + assertTrue(sut.sendUiState.value.paykitUsesUsdt) + assertEquals(endpoint.value, sut.sendUiState.value.usdtRecipient) + assertEquals("0.05", sut.sendUiState.value.paykitAmount) } @Test @@ -9790,7 +9845,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = "bcrt1qpreflightfailure", - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -9824,7 +9879,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { .thenReturn(Result.failure(PaykitPaymentRequestError.RequestUnavailable)) Result.success(Unit) } - stubSuccessfulOnchainSend(address, request.amountSats) + stubSuccessfulOnchainSend(address, request.amount.atomic) setActiveContactPaymentContext( testPublicKey, privateContext, @@ -9834,7 +9889,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = address, - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -9883,7 +9938,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = "bcrt1qdefinitefailure", - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -9913,14 +9968,14 @@ class AppViewModelSendFlowTest : BaseUnitTest() { .thenReturn(Result.success(Unit)) stubOnchainSend( address = "bcrt1quncertainfailure", - sats = request.amountSats, + sats = request.amount.atomic, result = Result.failure(IllegalStateException("outcome unknown")), ) setActiveContactPaymentContext(testPublicKey, privateContext, request, isInitialSubscriptionPayment = true) setSendState( SendUiState( address = "bcrt1quncertainfailure", - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -9934,7 +9989,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { val pendingRoute = SendRoute.Pending( request.paymentRequestId, - request.amountSats.toLong(), + request.amount.atomic.toLong(), observeResolution = false, isOnchain = true, ) @@ -9999,7 +10054,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { whenever(paykitPaymentRequestRepo.accept(request)).thenReturn(Result.success(Unit)) stubOnchainSend( address = "bcrt1quncertainreplacement", - sats = request.amountSats, + sats = request.amount.atomic, result = Result.failure(IllegalStateException("outcome unknown")), ) whenever(privatePaykitRepo.consumePrivatePaymentList(testPublicKey, privateContext)) @@ -10008,7 +10063,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = "bcrt1quncertainreplacement", - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -10023,7 +10078,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = "bcrt1qreplacement", - amount = replacementRequest.amountSats, + amount = replacementRequest.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -10064,7 +10119,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = "bcrt1qbookkeepingfailure", - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -10090,7 +10145,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = address, - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -10135,7 +10190,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = address, - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -10176,7 +10231,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = bolt11, - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.LIGHTNING, decodedInvoice = lightningInvoice(bolt11, amountSats = 2_501uL), isPaymentRequest = true, @@ -10312,7 +10367,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { setSendState( SendUiState( address = address, - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.ONCHAIN, speed = TransactionSpeed.Medium, isPaymentRequest = true, @@ -11820,6 +11875,16 @@ class AppViewModelSendFlowTest : BaseUnitTest() { settingsData.value = SettingsData(sharesPublicPaykitEndpoints = true) } + private suspend fun TestScope.verifyPaymentRequestPollingInterval() { + clearInvocations(paykitPaymentRequestRepo) + advanceTimeBy(10.seconds.inWholeMilliseconds - 1) + runCurrent() + verify(paykitPaymentRequestRepo, never()).refresh(any()) + advanceTimeBy(1) + runCurrent() + verify(paykitPaymentRequestRepo).refresh(any()) + } + private fun enablePaykitUi() { isPaykitEnabled.value = true } @@ -11914,6 +11979,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { privatePaymentContext: PrivatePaykitPaymentContext? = null, incomingPaymentRequest: PaykitPaymentRequest? = null, isInitialSubscriptionPayment: Boolean = false, + endpoints: List = emptyList(), ) { val field = AppViewModel::class.java.getDeclaredField("activeContactPaymentContext") field.isAccessible = true @@ -11924,6 +11990,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() { privatePaymentContext, incomingPaymentRequest, isInitialSubscriptionPayment, + endpoints = endpoints, ), ) } @@ -11990,6 +12057,178 @@ class AppViewModelSendFlowTest : BaseUnitTest() { fundingBalanceSats = fundingBalanceSats, ) + @Test + fun `asset switching preserves the entered value when the exchange rate is unavailable`() = test { + setSendState( + SendUiState( + address = REGTEST_ADDRESS, + usdtRecipient = "0x1111111111111111111111111111111111111111", + paykitUsesUsdt = true, + paykitAmount = "5", + isAmountInputValid = true, + ) + ) + sut.setSendEvent(SendEvent.PaymentMethodSwitch) + runCurrent() + assertTrue(sut.sendUiState.value.paykitUsesUsdt) + assertEquals("5", sut.sendUiState.value.paykitAmount) + assertTrue(sut.sendUiState.value.paykitRateUnavailable) + } + + @Test + fun `automatic USDT request finishes preparation and admits amount continue`() = test { + val endpoint = Endpoint(MethodId.UsdtArbitrum, "0x1111111111111111111111111111111111111111", null, null, "") + val request = paymentRequest().copy( + amount = PaykitAmount(PaykitAsset.USDT, 50_000u), + acceptedPaymentEndpointIdentifiers = listOf(endpoint.methodId.rawValue), + ) + whenever(privatePaykitRepo.beginPaymentRequest(request)).thenReturn( + Result.success(PublicPaykitPaymentResult.Opened(endpoint.value, endpoints = listOf(endpoint))) + ) + sut.setIsAuthenticated(true) + pendingPaykitPaymentRequests.value = listOf(request) + enablePaykitUi() + pubkyPublicKey.value = testPublicKey + sut.sendEffect.test { + runCurrent() + assertEquals(SendEffect.NavigateToAmount, awaitItem()) + assertNull((sut.currentSheet.value as? Sheet.Send)?.preparingRequest) + assertTrue(sut.sendUiState.value.paykitUsesUsdt) + sut.setSendEvent(SendEvent.AmountContinue) + assertEquals(SendEffect.NavigateToUsdtReview, awaitItem()) + } + } + + @Test + fun `converted request cannot enter review without a current exchange rate`() = test { + val endpoint = to.bitkit.repositories.Endpoint( + MethodId.UsdtArbitrum, + "0x1111111111111111111111111111111111111111", + null, + null, + "" + ) + val request = paymentRequest() + val field = AppViewModel::class.java.getDeclaredField("activeContactPaymentContext") + field.isAccessible = true + field.set( + sut, + ContactPaymentContext(testPublicKey, incomingPaymentRequest = request, endpoints = listOf(endpoint)) + ) + setSendState(SendUiState(paykitUsesUsdt = true, paykitAmount = "5", isAmountInputValid = true)) + sut.setSendEvent(SendEvent.AmountContinue) + runCurrent() + assertTrue(sut.sendUiState.value.paykitRateUnavailable) + assertFalse(sut.sendUiState.value.isAmountInputValid) + verify(paykitUsdtPayments, never()).prepare(any(), any(), anyOrNull(), anyOrNull()) + } + + @Test + fun `accepting a USDT request retains its send context until the flow closes`() = test { + val request = paymentRequest().copy( + amount = PaykitAmount(PaykitAsset.USDT, 50_000u), + acceptedPaymentEndpointIdentifiers = listOf(MethodId.UsdtArbitrum.rawValue), + ) + sut.showSheet(Sheet.Send()) + runCurrent() + setActiveContactPaymentContext( + testPublicKey, + incomingPaymentRequest = request, + endpoints = listOf( + Endpoint(MethodId.UsdtArbitrum, "0x1111111111111111111111111111111111111111", rawPayload = ""), + ), + ) + pendingPaykitPaymentRequests.value = listOf(request) + runCurrent() + whenever(paykitUsdtPayments.prepare(any(), any(), anyOrNull(), anyOrNull())).thenReturn(Result.success(Unit)) + whenever(paykitPaymentRequestRepo.accept(request)).doSuspendableAnswer { + pendingPaykitPaymentRequests.value = emptyList() + kotlinx.coroutines.yield() + Result.success(Unit) + } + setSendState(SendUiState(paykitUsesUsdt = true, paykitAmount = "0.05", isPaymentRequest = true)) + sut.setSendEvent(SendEvent.AmountContinue) + runCurrent() + sut.sendPaykitUsdt(mock()) + runCurrent() + assertTrue(sut.currentSheet.value is Sheet.Send) + assertEquals(request, activeContactPaymentContext()?.incomingPaymentRequest) + sut.hideSheet() + assertNull(activeContactPaymentContext()) + } + + @Test + fun `USDT execution rechecks request authorization after acceptance`() = test { + val request = paymentRequest().copy( + amount = PaykitAmount(PaykitAsset.USDT, 50_000u), + acceptedPaymentEndpointIdentifiers = listOf(MethodId.UsdtArbitrum.rawValue), + ) + setActiveContactPaymentContext( + testPublicKey, + incomingPaymentRequest = request, + endpoints = listOf( + Endpoint(MethodId.UsdtArbitrum, "0x1111111111111111111111111111111111111111", rawPayload = ""), + ), + ) + pendingPaykitPaymentRequests.value = listOf(request) + setSendState(SendUiState(paykitUsesUsdt = true, paykitAmount = "0.05", isPaymentRequest = true)) + sut.setSendEvent(SendEvent.AmountContinue) + runCurrent() + whenever(paykitUsdtPayments.prepare(any(), any(), anyOrNull(), anyOrNull())).thenReturn(Result.success(Unit)) + whenever(paykitPaymentRequestRepo.accept(request)).doSuspendableAnswer { + whenever(paykitPaymentRequestRepo.ensurePaymentAllowed(request)) + .thenReturn(Result.failure(PaykitPaymentRequestError.RequestUnavailable)) + Result.success(Unit) + } + + val result = runCatching { sut.sendPaykitUsdt(mock()) } + + assertTrue(result.exceptionOrNull() is PaykitPaymentRequestError.RequestUnavailable) + verify(paykitPaymentRequestRepo).ensurePaymentAllowed(request) + } + + @Test + fun `a request bound to USDT cannot switch to Bitcoin or prepare hardware payment`() = test { + val request = paymentRequest() + setActiveContactPaymentContext(testPublicKey, incomingPaymentRequest = request) + whenever(paykitUsdtPayments.hasBinding(request.id)).thenReturn(true) + setSendState( + SendUiState( + address = REGTEST_ADDRESS, + usdtRecipient = "0x1111111111111111111111111111111111111111", + paykitUsesUsdt = true, + paykitAmount = "5", + isPaymentRequest = true, + ) + ) + sut.setSendEvent(SendEvent.PaymentMethodSwitch) + runCurrent() + assertTrue(sut.sendUiState.value.paykitUsesUsdt) + assertFalse(sut.prepareHardwareContactPayment()) + verify(paykitPaymentProofRepo, never()).prepare(any(), any(), any(), any(), anyOrNull()) + } + + @Test + fun `a USDT binding prevents software Bitcoin dispatch when endpoints change`() = test { + val request = paymentRequest() + setActiveContactPaymentContext(testPublicKey, incomingPaymentRequest = request) + whenever(paykitUsdtPayments.hasBinding(request.id)).thenReturn(true) + setSendState( + SendUiState( + address = REGTEST_ADDRESS, + amount = request.amount.atomic, + payMethod = SendMethod.ONCHAIN, + isPaymentRequest = true, + ) + ) + sut.setSendEvent(SendEvent.PayConfirmed) + advanceUntilIdle() + verify(lightningRepo, never()).sendOnChain( + any(), any(), anyOrNull(), anyOrNull(), anyOrNull(), any(), anyOrNull(), any(), any(), any(), any() + ) + verify(paykitPaymentRequestRepo, never()).accept(any()) + verify(paykitPaymentProofRepo, never()).prepare(any(), any(), any(), any(), anyOrNull()) + } private fun privatePaymentContext(version: ULong?) = PrivatePaykitPaymentContext( paymentAppsByEndpoint = mapOf( MethodId.P2wpkh.rawValue to "bitkit", @@ -12002,8 +12241,8 @@ class AppViewModelSendFlowTest : BaseUnitTest() { private fun paymentRequest() = PaykitPaymentRequest( paymentRequestId = "request-id", counterparty = testPublicKey, - amountValue = "0.000025", - amountSats = 2_500uL, + paymentReference = "test-reference", + amount = PaykitAmount(PaykitAsset.BTC, 2_500uL), expiresAt = null, acceptedPaymentEndpointIdentifiers = listOf(MethodId.Bolt11.rawValue, MethodId.P2wpkh.rawValue), ) @@ -12011,8 +12250,9 @@ class AppViewModelSendFlowTest : BaseUnitTest() { private fun subscriptionStartingAt(startsAt: Instant) = PaykitSubscription( paymentRequestId = "subscription-id", counterparty = testPublicKey, - amountValue = "0.000025", - amountSats = 2_500uL, + amount = PaykitAmount(PaykitAsset.BTC, 2_500uL), + paymentReference = "fixture-reference", + pricing = PaykitRequestPricing(), note = "Weekly coffee", createdAt = Clock.System.now(), proposalExpiresAt = null, diff --git a/changelog.d/next/usdt.added.md b/changelog.d/next/usdt.added.md new file mode 100644 index 0000000000..eb1ecfe462 --- /dev/null +++ b/changelog.d/next/usdt.added.md @@ -0,0 +1 @@ +Send and receive USDT with fees paid in USDT, Paykit contact payments and requests, subscriptions, cross-network deposits, Earn address sharing, and encrypted payment recovery backups. diff --git a/docs/earn-receiving-details.md b/docs/earn-receiving-details.md new file mode 100644 index 0000000000..9e60309835 --- /dev/null +++ b/docs/earn-receiving-details.md @@ -0,0 +1,39 @@ +# Earn receiving-details claims + +Bitkit lets an Earn service request a Bitcoin watch-only account, the existing USDT address on Arbitrum One, or both through the existing Pubky Auth approval flow. This contract covers address sharing, not USDT invoicing, payment verification or purchase delivery. + +## Request and approval + +Use exactly one `x-bitkit-claim` query parameter: + +| Claim | Shared details | +| --- | --- | +| `watch-only-account-v1` | A separate native-SegWit Bitcoin account, using the existing 84-byte payload | +| `usdt-address-v1` | The existing USDT Arbitrum receiving endpoint | +| `payment-details-v1` | Both that endpoint and a separate Bitcoin account | + +All three require exactly `/pub/paykit/:rw`. Unknown or repeated claim parameters and mismatched capabilities are rejected. Changing the claim changes the request identity and companion channel. + +The user first sees the existing Earn introduction, then the authorization review showing the requested assets. The USDT address is expandable and copyable. Approval is unavailable until the address can be read, and Bitkit re-reads it before sending to ensure it is the address reviewed. Canceling before authorization shares nothing and allocates no Bitcoin account. + +USDT sharing creates no account, changes no public-sharing preference and gives no permission to spend. The receiver can observe the account's public balance and transaction history. Different services receive the same USDT address. Bitcoin sharing retains its separate account allocation and tracked retry/recovery lifecycle. + +## Payload + +For `usdt-address-v1`, the unsigned payload is a UTF-8 JSON object with exactly the `usdt-arbitrum-address` key. Its endpoint contains string fields `value` (the EVM address), `chain_id` (`42161`) and `token` (`0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9`). + +For `payment-details-v1`, the unsigned JSON additionally contains `bitcoin_account`, with `account_index` (an unsigned integer), `address_type` (`nativeSegwit`) and `xpub` (Base58Check text). Wallet-local names and identifiers are not shared. The xpub's version identifies its Bitcoin network; the server must check it against its configured network. + +JSON key order is not significant. Verify the signature over the received bytes before decoding; do not reconstruct or reserialize the object for verification. The existing `watch-only-account-v1` binary format is unchanged. + +## Signed delivery + +Use Paykit's companion-claim approval API with the exact selected claim name. The signature input is UTF-8 `x-bitkit-claim||`, followed by SHA256 of the decoded 32-byte auth request secret, followed by the unsigned payload bytes. Paykit appends the 64-byte Ed25519 signature and encrypts the signed payload using the existing XSalsa20-Poly1305 envelope. + +The companion channel is base64url-no-pad of BLAKE3 over UTF-8 `|` followed by the decoded request secret. The normal AuthToken channel is unchanged. Claim delivery precedes normal auth approval. The signature is verified against the creator's authenticated Pubky public key. It binds the receiving details to that identity and request, not to ownership of an EVM private key. + +## Server integration + +Paykit Server's current implementation accepts only `watch-only-account-v1`. Supporting the new claim names requires using the requested claim name for channel derivation and signature verification, parsing the appropriate payload after verification, validating the pinned endpoint and optional Bitcoin account, and durably storing the selected receiving details before acknowledging setup. Existing Bitcoin setup and stored credentials must remain readable; neither USDT-only sharing nor combined sharing authorizes deleting them. + +The server must not treat a shared USDT address as an enabled USDT checkout method. USDT invoice creation and payment verification are separate work. A server should issue these new claim requests only when it can accept and store them. Bitkit should not advertise a completed production Earn integration until that server behavior is available and tested together. diff --git a/docs/screens-map.md b/docs/screens-map.md index bac060af52..01677c6e87 100644 --- a/docs/screens-map.md +++ b/docs/screens-map.md @@ -221,6 +221,13 @@ Frame names are stable across handoff iterations; node ids are not, so the map l | - | - | | BuyIntroScreen.kt | Buy Bitcoin › Buy Bitcoin | +## ui/screens/wallets/usdt + +| Android | Figma | +| - | - | +| UsdtDepositReceiveScreen.kt | `todo` | +| UsdtWalletScreen.kt | `todo` | + ## ui/screens/wallets/withdraw | Android | Figma | diff --git a/docs/usdt-qa.md b/docs/usdt-qa.md new file mode 100644 index 0000000000..a432a18189 --- /dev/null +++ b/docs/usdt-qa.md @@ -0,0 +1,74 @@ +# USDT manual integration checks + +The journey environment does not provide funded Arbitrum or cross-network accounts, controlled USDT provider/RPC/bundler responses, encrypted VSS outages, or a subscription billing clock. These checks require the named external setup. Record the build, configuration, actual transaction evidence, and whether evidence came from a fixture or a live service. Wallet resets and transfers require the owner’s authorization. + +The drivable wallet navigation and request/subscription UI paths are in `journeys/usdt-wallet-navigation.xml` and `journeys/paykit-quoted-usdt.xml`. The manual checks below are specifications, not evidence of execution. + +## usdt bridge quotes + +A funded Arbitrum wallet uses the real gateway with USDT0 and Orchestra enabled. This journey obtains quotes only; do not swipe to pay or create any funded order. + +- [ ] Open USDT from the home balance, then Send. Verify UsdtNetwork offers Arbitrum and the enabled provider destinations. +- [ ] Choose Base, open manual entry and enter an owned EVM address. Enter an affordable USDT amount and continue to review. +- [ ] Verify the review displays Base, the selected Orchestra provider in details, estimated destination receipt, included bridge cost, maximum source fee and maximum total debit. All amounts use USDT. +- [ ] Close without paying. Start a send to Polygon and obtain a quote to an owned address. Verify the selected provider is shown and the same amount and fee fields remain clear. +- [ ] Close without paying. Select Solana and verify an EVM address is rejected, then select Tron and verify an EVM address is rejected. +- [ ] Close Send and verify the home balance has not changed and no outgoing payment was created. + +## usdt outbound bridge + +USDT is configured against the real gateway; both app and service enable Polygon through USDT_BRIDGE_NETWORKS, and USDT_BRIDGES_URL enables Orchestra destinations. Use a funded wallet and an owned destination address. Mainnet transfers require authorization. Preserve wallet data, keep authentication out of recordings, and record actual transaction hashes and fees. + +- [ ] Open the home screen and verify the USDT balance, then open USDT and Send. +- [ ] Choose Polygon in UsdtNetwork and open manual address entry. Verify an invalid address and an Arbitrum-specific payment URI cannot advance. +- [ ] Select Arbitrum and accept an Arbitrum payment URI. Go back from amount entry and change to Polygon. Verify the previous recipient and amount are cleared and must be entered again. +- [ ] Enter the owned destination address and a small USDT amount. Verify the review shows Polygon, the full recipient, selected provider, estimated received amount, included Orchestra routing cost where applicable, additional maximum source fee and maximum total debit in USDT. +- [ ] Authorize one payment. Verify it appears in activity as awaiting cross-network delivery rather than claiming delivery from source-chain execution alone. +- [ ] Restart the app and verify the same transfer continues tracking without sending a second payment. +- [ ] Verify destination delivery independently from its transaction receipt, token, recipient, amount and balance. Confirm activity details update and the Arbitrum wallet retains zero ETH. +- [ ] Return home and verify the updated USDT balance. Verify Paykit payment choices remain Arbitrum-only. + +## usdt cross-network receive + +Requires a wallet with USDT enabled and a matching backend with Orchestra credentials and accepted source networks enabled. Address and estimate checks do not move funds. Externally funded settlement and provider-held refunds require separate manual tests. + +- [ ] Open the USDT wallet and Receive. Verify direct Arbitrum One receiving is available. +- [ ] Open the network selector. Verify only configured supported sources are offered: Ethereum, Tron, Solana, Polygon, Base and BNB Smart Chain. +- [ ] Select each enabled source network, enter an amount within its live limits, and get its deposit address. Verify the selected network, reusable address, estimated received amount and deduction are shown. Verify the QR and Copy action use the same address. +- [ ] Return to Arbitrum One and verify its original wallet address remains unchanged. +- [ ] Open cross-network deposit activity. Verify empty history and Load more work without showing a failure. +- [ ] Enter an amount below the route minimum and verify the limit error appears without a deposit address. +- [ ] Edit the amount. Verify the old limit error clears immediately, one short fee hint is shown above the keypad divider, and the keypad and button remain fully visible. Get an address with an amount within the route limits. +- [ ] Reopen the app and verify the reusable address and deposit history are recovered. Inspect any existing deposit details without claiming a new settlement. + +## usdt payment recovery + +Two linked wallets with USDT enabled and separately authorized payment funds. Preserve wallet data. This covers normal UI restart recovery; controlled VSS/RPC/bundler outages, missing storage and cross-platform backup injection require separate manual tests. + +- [ ] Create a USD subscription payable in USDT and open an installment payment review. +- [ ] Verify recipient, amount and maximum fee, then authorize one installment payment. +- [ ] Once dismissal is permitted, close the payment sheet and reopen the USDT wallet. Record the displayed transfer and request attribution. +- [ ] Restart the app and reopen that transfer. Verify it retains the same activity entry and request attribution without asking for a second payment approval. +- [ ] If the transfer is still pending, try to cancel its subscription. Verify unresolved payment execution prevents cancellation. +- [ ] Refresh until the transfer settles or reports a terminal outcome. Verify its activity details show that outcome and no second outgoing transfer was created. + +## Paykit settlement, later installments and evidence + +Requires funded Arbitrum accounts, controlled billing time, and controlled receipt evidence, none of which is listed in Capabilities. + +- [ ] Open the home screen and verify the USDT balance is visible and a funded USDT wallet does not show empty-wallet onboarding. +- [ ] Continue to review and verify recipient, amount and additional USDT fee before authorizing payment. +- [ ] Complete payment with the receiver viewing Subscriptions and verify success, green receive celebration, activity details and the actual received amount on both wallets. +- [ ] Restart both apps and verify the same payment history and request attribution, with no second payment. +- [ ] Create a BTC request accepting Bitcoin and USDT. Switch the payer between Savings, Spending when enabled, and USDT; verify the requested value is preserved and the quoted amount and fee appear before approval. +- [ ] Using a controlled billing clock, advance to the next installment with the requester offline. Verify its USD amount still maps exactly to USDT, the fee remains additional, and earlier paid periods remain unchanged. +- [ ] Using controlled payment evidence, verify underpayment and payment after expiry show actual received funds and the corresponding status, without reporting the transfer as failed. +- [ ] Pay a contact directly without a request and verify the normal asset selector, send review and activity attribution still work. Verify selecting USDT does not request camera access for an already resolved recipient. + +## Backup and dependency failures + +Requires disposable wallets and controlled VSS/RPC/bundler/storage endpoints; no Android device harness providing these controls is supplied here. + +- [ ] Make VSS unavailable before approving one payment. Verify a visible backup failure and no bundler submission. Restore VSS and verify only the original approved operation can continue. +- [ ] Restore its encrypted envelope on the opposite platform with the same authorized seed. Verify one operation, request attribution and proof delivery, without a second approval or transfer. +- [ ] Restore with unavailable local storage. Verify restore remains incomplete and no replacement wallet backup is uploaded. diff --git a/docs/usdt.md b/docs/usdt.md new file mode 100644 index 0000000000..d856014765 --- /dev/null +++ b/docs/usdt.md @@ -0,0 +1,43 @@ +# USDT configuration + +USDT uses Arbitrum One regardless of the Bitcoin network setting. Gradle reads `USDT_RPC_URL` and `USDT_BUNDLER_URL` from local properties/environment configuration. Both must point to the controlled service's credential-free HTTPS chain and bundler routes. Missing endpoints hide the wallet entry. + +Optional `USDT_DEPOSITS_URL` enables wallet-signed Orchestra deposits. Provider keys remain on the service. Source support covers Ethereum, Tron, Solana, Polygon, Base and BNB Smart Chain, subject to explicit service enablement and live route availability. Each source requires funded acceptance before release. Users approve a source-network refund address when requesting an eligible refund; unconverted Tron refunds require provider support. History and addresses recover under the same provider partner account. Linked order amounts are batch totals. Outbound USDT0 destinations are enabled with `USDT_BRIDGE_NETWORKS`, a comma-separated subset of `ethereum,polygon,plasma,stable`, matching the service configuration. Empty configuration offers Arbitrum only. Paykit always uses direct Arbitrum payments. + +The `bitkitCoreAar` Gradle property selects an absolute local release AAR. Bindings and native libraries must come from the same core build. + +For a local emulator gateway, use loopback URLs and ADB reverse port forwarding. Core allows HTTP only on localhost or 127.0.0.1; the emulator host alias 10.0.2.2 requires HTTPS. + +USDT follows the existing UI → ViewModel → repository → Rust ownership. The repository manages foreground refresh, receive/pending refresh and rate-limit backoff. Native payment authentication precedes signing. Transaction IDs and explorer links appear when a transaction hash is available; Arbiscan links are built by the app. Failed/replaced payment details do not claim recipient delivery. Wallet wipe closes core handles before deleting wallet-specific USDT files. + +Protocol and recovery behavior belong to bitkit-core's USDT module documentation; provider deployment belongs to the service documentation. + +History catch-up is deferred while the USDT send sheet is open. Balance and pending-payment recovery continue; a history scan already in progress is allowed to finish. Unknown deposit-provider statuses require attention instead of appearing as ordinary pending deposits. Cross-network payment details label the recipient amount as expected until delivery is confirmed. + +## Paykit + +Paykit uses a direct Arbitrum USDT0 endpoint (`usdt-arbitrum-address`). Existing public/private sharing settings control publication. The payload binds the address, chain 42161 and pinned token; bridge routes are excluded from Paykit choices. + +Bitkit creates BTC or USD requests and also reads USDT-denominated requests from other wallets. The accepted methods are immutable request terms. Every accepted cross-asset currency has an explicit requester-supplied rate; the denominating asset needs no conversion. USD/USDT is exactly 1:1. Bitcoin rates come from the existing BTC/USD source when issuing terms, not when verifying received funds. External requests without rates allow only same-asset payment. A listed method without its required rate cannot be used. + +Required amounts are rounded upward once to Bitkit's payment precision (satoshis for Bitcoin and six decimal places for USDT). Fees are additional. Approval pins the amount, quote identifier and validity interval; changes requiring new approval return through review. Receipt validation uses those terms with no percentage tolerance or later market repricing. + +One-time requests use the selected expiry as both the acceptance limit and actual payment deadline. Bitkit-created subscriptions accept only enabled Bitcoin methods (Savings/Spending) for BTC amounts, or USDT for USD amounts. USD subscriptions include a fixed 1:1 USDT rate for every installment; BTC subscriptions need no conversion. No recurring quote publisher or requester availability is needed to price later installments. External per-period quotes and absolute or period-relative deadlines are still honored, and existing subscription terms and proof history are not rewritten. Each installment requires payer approval; accepting a subscription does not authorize automatic payments. + +Before sending USDT, the app durably associates the request and billing period with the core payment ID and immutable proof binding. After successful execution, core signs the released `erc20-transfer-eip712` proof over both participants, the receiving payment app, request reference, endpoint, billing period and selected quote. The full proof envelope is size-checked before sending. Retries and restarts deliver the same proof without another transfer; a replacement payment is allowed only for an unstarted attempt without a core operation or a definitively failed/replaced operation. Wallet backups retain these associations, started-payment markers, received-payment identities and selected conversion quotes; missing execution history after restore never authorizes a replacement payment. + +Receipts require successful canonical execution, the correct chain/token/recipient and the transfer sender's signature. A payment is identified by verified chain, transaction and original receipt-log position and can satisfy at most one request/period. Real funds are displayed as received, underpaid or after expiry, with their actual amount. Overpayment is accepted; underpayment and late payment do not start a dispute, refund or top-up workflow. Unavailable evidence remains pending; a previously verified receipt is rechecked without discarding its attribution. A submitted USDT proof remains visible while verification is pending; only a verified, sufficiently funded, timely receipt advances a received subscription's paid count and paid-through date. Bitcoin retains its existing settlement behavior. + +## Encrypted recovery backups + +The wallet backup includes core's portable USDT recovery snapshot alongside Paykit request bindings, pending proofs and received-payment identities. It contains signed operations and stable activity IDs, but no private keys or seed. The existing VSS client encrypts and authenticates the complete envelope. History cursors and unsigned quotes are rebuilt locally. + +Core waits for the app to acknowledge a VSS upload before first submission or automatic rebroadcast. If backup is unavailable, the signed payment stays pending locally and no submission is attempted; recovery retries the same operation once backup is available, or reconciles its expiry against the chain. Wallet uploads are serialized so an older background snapshot cannot replace a payment's acknowledged backup. + +Restore merges records for the derived account without overwriting newer local outcomes. Signed operations imported into an empty database are reconciled against chain evidence before retry; already discovered transactions retain their restored application IDs. A failed restore retains the downloaded envelope and blocks replacement backups. Bitcoin-only backups remain readable. Seed-only recovery restores account control and chain history, but cannot reconstruct a never-mined signed operation or its Paykit attribution. Missing evidence never authorizes a second payment. + +## Outbound provider selection + +Configure `USDT_BRIDGES_URL` with the gateway's credential-free `/v1/usdt/bridges` route to enable Orchestra. The network selector combines the gateway's enabled Orchestra destinations with the app's `USDT_BRIDGE_NETWORKS` USDT0 destinations. Direct Arbitrum and Paykit remain unchanged. Core chooses the best usable estimated receipt per maximum total source debit, including the source paymaster fee; a tie prefers USDT0. + +Orchestra routing costs are deducted from the entered USDT principal. Review shows estimated destination receipt, included route cost, additional maximum source fee and maximum total debit. Fees remain in USDT, including when the provider uses intermediate assets. The chosen quote is frozen before signing. Funding and delivery are separate: activity retains the original recipient and network through pending delivery, provider attention and a verified Arbitrum refund. A timeout, restart or provider failure never starts a payment through another provider. Encrypted backup includes the funding plan and tracking ticket; seed-only history cannot reconstruct them. diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index d45449a5e7..f85b7edda1 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -21,7 +21,7 @@ activity-compose = { module = "androidx.activity:activity-compose", version = "1 appcompat = { module = "androidx.appcompat:appcompat", version = "1.7.1" } barcode-scanning = { module = "com.google.mlkit:barcode-scanning", version = "17.3.0" } biometric = { module = "androidx.biometric:biometric", version = "1.4.0-alpha05" } -bitkit-core = { module = "com.synonym:bitkit-core-android", version = "0.5.18" } +bitkit-core = { module = "com.synonym:bitkit-core-android", version = "0.8.0-rc1" } paykit = { module = "com.synonym:paykit-android", version = "0.1.0-rc74" } bouncycastle-provider-jdk = { module = "org.bouncycastle:bcprov-jdk18on", version = "1.83" } camera-camera2 = { module = "androidx.camera:camera-camera2", version.ref = "camera" } diff --git a/journeys/paykit-quoted-usdt.xml b/journeys/paykit-quoted-usdt.xml new file mode 100644 index 0000000000..06582ab6dc --- /dev/null +++ b/journeys/paykit-quoted-usdt.xml @@ -0,0 +1,11 @@ + + Two linked Bitkit wallets with Paykit and USDT enabled, sharing enabled by their owners, and a fresh BTC/USD rate. No funded account is required: stop at Amount and do not authorize a payment. Funded settlement, later installments and controlled evidence checks are manual tests in docs/usdt-qa.md. + + Open a linked contact and create a USD payment request. Verify BTC and USD are the denomination choices and enabled receiving methods start selected. Verify one Savings choice covers Bitcoin address types, Spending appears when Lightning is enabled, and USDT is available. + Deselect all receiving choices and verify sending the request is disabled. Select only USDT, enter 1 USD, select an expiry and send the request. + On the payer, open the request. Verify Amount shows exactly 1 USDT, the amount cannot be edited, and no Bitcoin funding source is offered. Close without continuing. + Create a BTC request accepting Bitcoin and USDT. On the payer's Amount screen, switch between available Savings, Spending and USDT sources. Verify the displayed amount preserves the request's quoted value and cannot be edited. Close without continuing. + Create a USD subscription. Verify only USDT is accepted at fixed 1:1 parity. Propose it to the linked contact. On the payer, review its amount, recurrence and payment method; close before subscribing. + Create a BTC subscription and verify that only enabled Savings and Spending methods are accepted, with no USDT choice. Close without proposing. + + diff --git a/journeys/pubky-auth/share-receiving-details.xml b/journeys/pubky-auth/share-receiving-details.xml new file mode 100644 index 0000000000..8d3d067178 --- /dev/null +++ b/journeys/pubky-auth/share-receiving-details.xml @@ -0,0 +1,13 @@ + + Use an onboarded wallet with a Pubky identity and configured USDT. Use a local test auth request; cancel before Authorize so no receiving details or session are exported. + + Open the existing watch-only setup fixture with x-bitkit-claim=usdt-address-v1 + Verify the Earn USDT introduction, then tap Approve + Verify only USDT Arbitrum details, the existing address and balance/history disclosure are shown + Expand the address and copy it; verify it matches the wallet receive address + Cancel and verify no Bitcoin account was created + Repeat with x-bitkit-claim=payment-details-v1; verify Bitcoin and USDT appear together, then cancel + Repeat with x-bitkit-claim=watch-only-account-v1; verify only Bitcoin is requested, then cancel + With USDT unavailable, verify USDT authorization is disabled and Retry reloads the address + + diff --git a/journeys/subscriptions/create-and-propose.xml b/journeys/subscriptions/create-and-propose.xml index 5c590f8dc9..9317d8057f 100644 --- a/journeys/subscriptions/create-and-propose.xml +++ b/journeys/subscriptions/create-and-propose.xml @@ -12,7 +12,7 @@ Tap Create (testTag "SubscriptionCreate") Verify the create sheet (testTag "CreateSubscription") appears with Choose Recipient disabled Tap the amount pencil, enter "5000" on the keypad, and tap Continue - Verify the amount reads 5,000 sats + Verify the amount reads 5,000 sats and the accepted methods show only enabled Savings or Spending options, with no USDT Type "Journey Sub" into the subscription name field (testTag "SubscriptionName") Enter 600 ASCII letters in the description field (testTag "SubscriptionDescription") Verify the frequency selector has "Monthly" selected diff --git a/journeys/usdt-wallet-navigation.xml b/journeys/usdt-wallet-navigation.xml new file mode 100644 index 0000000000..da33097fbf --- /dev/null +++ b/journeys/usdt-wallet-navigation.xml @@ -0,0 +1,10 @@ + + Use an onboarded wallet in an E2E build with USDT RPC and bundler URLs configured. No chain funding or live provider is required. A network error may be visible when services are offline; no payment is submitted. + + Open USDT from Home and verify the wallet screen uses the same balance, action buttons and activity layout as the Bitcoin wallet. + Open Receive. Verify the address starts with 0x and the network is Arbitrum One. Open details and verify Copy and the QR show the same address. + Close Receive, open Send and manual entry. Enter an invalid Bitcoin address and verify the address error prevents continuing. + Replace it with an owned valid EVM address. Continue to Amount, enter six decimal places and try a seventh; verify the amount remains limited to six. Close before requesting a quote. + Return Home and open Bitcoin Receive. Verify the Bitcoin address, network and amount controls remain separate from USDT. + + diff --git a/settings.gradle.kts b/settings.gradle.kts index b1aede9e15..ab918f74e7 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -37,7 +37,10 @@ dependencyResolutionManagement { repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS) repositories { mavenLocal { - content { excludeModule("com.synonym", "paykit-android") } + content { + excludeModule("com.synonym", "paykit-android") + excludeModule("com.synonym", "bitkit-core-android") + } } google() mavenCentral() From b7a29d03980c1fb66ef87504ca8c20bf359177fe Mon Sep 17 00:00:00 2001 From: benk10 Date: Tue, 6 Oct 2026 22:42:47 -0500 Subject: [PATCH 02/62] fix: preserve payment recovery and final authorization --- .../java/to/bitkit/models/TrezorPublicKey.kt | 32 +++++ .../repositories/PaykitUsdtPaymentRepo.kt | 3 +- .../bitkit/repositories/PrivatePaykitRepo.kt | 3 +- .../java/to/bitkit/repositories/TrezorRepo.kt | 3 +- .../java/to/bitkit/repositories/UsdtRepo.kt | 3 +- .../to/bitkit/services/PaykitSdkService.kt | 8 +- .../ui/screens/trezor/PublicKeySection.kt | 13 +- .../ui/screens/trezor/TrezorPreviewData.kt | 7 +- .../ui/screens/trezor/TrezorViewModel.kt | 18 ++- .../to/bitkit/models/TrezorPublicKeyTest.kt | 96 +++++++++++++++ .../PaykitPaymentProofRepoTest.kt | 3 +- ...aykitPaymentRequestRepoSubscriptionTest.kt | 5 +- .../PaykitPaymentRequestRepoTest.kt | 2 +- .../repositories/PaykitUsdtPaymentRepoTest.kt | 20 ++- .../repositories/PrivatePaykitRepoTest.kt | 2 +- .../to/bitkit/repositories/TrezorRepoTest.kt | 115 ++++++++++++++---- .../to/bitkit/repositories/UsdtRepoTest.kt | 30 +++++ .../bitkit/services/PaykitSdkServiceTest.kt | 4 +- .../ui/screens/trezor/TrezorViewModelTest.kt | 27 ++++ .../screens/wallets/usdt/UsdtViewModelTest.kt | 23 ++-- .../viewmodels/AppViewModelSendFlowTest.kt | 9 +- docs/usdt.md | 2 + 22 files changed, 361 insertions(+), 67 deletions(-) create mode 100644 app/src/main/java/to/bitkit/models/TrezorPublicKey.kt create mode 100644 app/src/test/java/to/bitkit/models/TrezorPublicKeyTest.kt diff --git a/app/src/main/java/to/bitkit/models/TrezorPublicKey.kt b/app/src/main/java/to/bitkit/models/TrezorPublicKey.kt new file mode 100644 index 0000000000..46b3166658 --- /dev/null +++ b/app/src/main/java/to/bitkit/models/TrezorPublicKey.kt @@ -0,0 +1,32 @@ +package to.bitkit.models + +import com.synonym.bitkitcore.AddressType +import com.synonym.bitkitcore.TrezorPublicKeyResponse + +/** + * Account key to persist on a known device for [addressType]. + * + * Since bitkit-core 0.7.0 [TrezorPublicKeyResponse.xpub] is always a normalized xpub/tpub, while known + * devices paired on earlier versions stored the firmware's SLIP-132 form (ypub/zpub/upub/vpub) for + * BIP-49/BIP-84. Those strings feed [walletKey], entry matching and `deriveWalletId`, so they must stay + * byte-identical: SegWit types keep `xpubSegwit`, Legacy and Taproot keep `xpub` (Taproot `xpubSegwit` + * can be a descriptor). See bitkit-core `src/modules/trezor/README.md`, + * "Migrating to trezor-connect-rs 10.0.0 (Core 0.7.0)". + */ +fun TrezorPublicKeyResponse.storedAccountKey(addressType: AddressType): String = when (addressType) { + AddressType.P2SH, AddressType.P2WPKH -> xpubSegwit ?: xpub + else -> xpub +} + +/** Address type for the BIP purpose of [path] (e.g. `m/84'/1'/0'` is [AddressType.P2WPKH]), or null. */ +fun addressTypeForDerivationPath(path: String): AddressType? { + val segments = path.split("/") + if (segments.size < 2 || segments[0] != "m") return null + return when (segments[1].trimEnd('\'', 'h', 'H')) { + "44" -> AddressType.P2PKH + "49" -> AddressType.P2SH + "84" -> AddressType.P2WPKH + "86" -> AddressType.P2TR + else -> null + } +} diff --git a/app/src/main/java/to/bitkit/repositories/PaykitUsdtPaymentRepo.kt b/app/src/main/java/to/bitkit/repositories/PaykitUsdtPaymentRepo.kt index a209b71ad3..8b209f8c87 100644 --- a/app/src/main/java/to/bitkit/repositories/PaykitUsdtPaymentRepo.kt +++ b/app/src/main/java/to/bitkit/repositories/PaykitUsdtPaymentRepo.kt @@ -215,8 +215,7 @@ class PaykitUsdtPaymentRepo @Inject constructor( runSuspendCatching { setPaymentStarted(quote.id, true).getOrThrow() val result = runSuspendCatching { - beforeSend() - usdt.send(quote).getOrThrow() + usdt.send(quote, beforeSend).getOrThrow() } if (result.isFailure) { val history = storedTransfer(quote.id) diff --git a/app/src/main/java/to/bitkit/repositories/PrivatePaykitRepo.kt b/app/src/main/java/to/bitkit/repositories/PrivatePaykitRepo.kt index 66e3ea5bc1..a1b856cc7a 100644 --- a/app/src/main/java/to/bitkit/repositories/PrivatePaykitRepo.kt +++ b/app/src/main/java/to/bitkit/repositories/PrivatePaykitRepo.kt @@ -696,7 +696,8 @@ class PrivatePaykitRepo @Inject constructor( pubkyService.currentPublicKey() ?: return@runSuspendCatching null json.encodeToString( PrivatePaykitBackup( - sdkState = paykitSdkService.exportBackupState(), + // This snapshot can be required before broadcast; it must not wait for payment to finish. + sdkState = paykitSdkService.exportBackupState(Priority.Interactive), consumedPrivatePaymentListVersions = ensureState().contacts .mapNotNull { (publicKey, contactState) -> contactState.consumedPrivatePaymentListVersion?.let { publicKey to it } diff --git a/app/src/main/java/to/bitkit/repositories/TrezorRepo.kt b/app/src/main/java/to/bitkit/repositories/TrezorRepo.kt index 8831d90d9c..39e10d7ade 100644 --- a/app/src/main/java/to/bitkit/repositories/TrezorRepo.kt +++ b/app/src/main/java/to/bitkit/repositories/TrezorRepo.kt @@ -75,6 +75,7 @@ import to.bitkit.models.deriveHardwareWalletId import to.bitkit.models.findHardwareWalletId import to.bitkit.models.isReplacedBy import to.bitkit.models.matches +import to.bitkit.models.storedAccountKey import to.bitkit.models.toAccountDerivationPath import to.bitkit.models.toCoreNetwork import to.bitkit.models.toSettingsString @@ -1317,7 +1318,7 @@ class TrezorRepo @Inject constructor( path = path, coin = coin, showOnTrezor = false, - ).xpub + ).storedAccountKey(addressType) } if (result.isSuccess) { return XpubFetchResult(xpub = result.getOrThrow()) diff --git a/app/src/main/java/to/bitkit/repositories/UsdtRepo.kt b/app/src/main/java/to/bitkit/repositories/UsdtRepo.kt index e73e3b2f1e..653d4021d3 100644 --- a/app/src/main/java/to/bitkit/repositories/UsdtRepo.kt +++ b/app/src/main/java/to/bitkit/repositories/UsdtRepo.kt @@ -175,9 +175,10 @@ class UsdtRepo @Inject constructor( } } - suspend fun send(quote: UsdtQuote) = withContext(ioDispatcher) { + suspend fun send(quote: UsdtQuote, beforeSend: suspend () -> Unit = {}) = withContext(ioDispatcher) { mutex.withLock { runSuspendCatching { + beforeSend() service.send(quote).also { transfer -> _state.update { it.copy( diff --git a/app/src/main/java/to/bitkit/services/PaykitSdkService.kt b/app/src/main/java/to/bitkit/services/PaykitSdkService.kt index 24b91fedb3..b1ffba773b 100644 --- a/app/src/main/java/to/bitkit/services/PaykitSdkService.kt +++ b/app/src/main/java/to/bitkit/services/PaykitSdkService.kt @@ -1261,16 +1261,16 @@ class PaykitSdkService @Inject constructor( }, ) - suspend fun exportBackupState(): String { + internal suspend fun exportBackupState(priority: Priority = Priority.Background): String { isSetup.await() val generation = runtimeGeneration return operationLock.withoutLock { var backup: String? do { - isPaymentSubmissionActive.first { !it } - backup = operationLock.withLock(Priority.Background) { + if (priority == Priority.Background) isPaymentSubmissionActive.first { !it } + backup = operationLock.withLock(priority) { check(runtimeGeneration == generation) { "Paykit runtime changed before backup export" } - if (isPaymentSubmissionActive.value) return@withLock null + if (priority == Priority.Background && isPaymentSubmissionActive.value) return@withLock null withPaykitKey { completeSdkCall { it.exportBackupString() } } } } while (backup == null) diff --git a/app/src/main/java/to/bitkit/ui/screens/trezor/PublicKeySection.kt b/app/src/main/java/to/bitkit/ui/screens/trezor/PublicKeySection.kt index 86480a55c0..dce266d87d 100644 --- a/app/src/main/java/to/bitkit/ui/screens/trezor/PublicKeySection.kt +++ b/app/src/main/java/to/bitkit/ui/screens/trezor/PublicKeySection.kt @@ -78,12 +78,15 @@ internal fun PublicKeySection( AnimatedVisibility(visible = trezorState.lastPublicKey != null) { trezorState.lastPublicKey?.let { response -> - val onCopyXpub = copyToClipboard(text = response.xpub, label = "xpub") + val onCopyAccountKey = copyToClipboard( + text = response.displayablePublicKey, + label = "Account public key", + ) val onCopyPublicKey = copyToClipboard(text = response.publicKey, label = "Public Key") Column { VerticalSpacer(16.dp) Caption( - text = "xpub:", + text = "Account public key:", color = Colors.White50, ) VerticalSpacer(4.dp) @@ -96,18 +99,18 @@ internal fun PublicKeySection( verticalAlignment = Alignment.CenterVertically ) { Caption( - text = response.xpub, + text = response.displayablePublicKey, color = Colors.Brand, modifier = Modifier.weight(1f), ) HorizontalSpacer(8.dp) Icon( painter = painterResource(R.drawable.ic_copy), - contentDescription = "Copy xpub", + contentDescription = "Copy account public key", tint = Colors.Brand, modifier = Modifier .size(20.dp) - .clickableAlpha(onClick = onCopyXpub) + .clickableAlpha(onClick = onCopyAccountKey) ) } diff --git a/app/src/main/java/to/bitkit/ui/screens/trezor/TrezorPreviewData.kt b/app/src/main/java/to/bitkit/ui/screens/trezor/TrezorPreviewData.kt index 966cadb388..eb50ffcb13 100644 --- a/app/src/main/java/to/bitkit/ui/screens/trezor/TrezorPreviewData.kt +++ b/app/src/main/java/to/bitkit/ui/screens/trezor/TrezorPreviewData.kt @@ -109,6 +109,9 @@ internal object TrezorPreviewData { private const val SAMPLE_XPUB = "xpub6CUGRUonZSQ4TWtTMmzXdrXDtypWKiKrhko4egpiMZbpiaQL2jkwSB1icqY" + "h2cfDfVxdx4df189oLKnC5fSwqPfgyP3hooxujYzAu3fDVmz" + private const val SAMPLE_ZPUB = + "zpub6r8o2p9croV2A7Gh2VZn42iEEv7QCxJrXyqWDUcV7aMapn2nY464gJKzfFT" + + "s2Ry4UnCFT1pmvSru6u1KX4GyRs2ti4SYydbtH17Tg8wL57f" private const val SAMPLE_PUBKEY = "02a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2" private const val SAMPLE_CHAIN_CODE = @@ -121,9 +124,9 @@ internal object TrezorPreviewData { val samplePublicKeyResponse = TrezorPublicKeyResponse( xpub = SAMPLE_XPUB, - xpubSegwit = null, + xpubSegwit = SAMPLE_ZPUB, descriptor = null, - displayablePublicKey = SAMPLE_XPUB, + displayablePublicKey = SAMPLE_ZPUB, path = "m/84'/0'/0'", publicKey = SAMPLE_PUBKEY, chainCode = SAMPLE_CHAIN_CODE, diff --git a/app/src/main/java/to/bitkit/ui/screens/trezor/TrezorViewModel.kt b/app/src/main/java/to/bitkit/ui/screens/trezor/TrezorViewModel.kt index e79abfdef6..0ff70e1aba 100644 --- a/app/src/main/java/to/bitkit/ui/screens/trezor/TrezorViewModel.kt +++ b/app/src/main/java/to/bitkit/ui/screens/trezor/TrezorViewModel.kt @@ -33,6 +33,8 @@ import to.bitkit.env.Env import to.bitkit.models.HwWalletId import to.bitkit.models.KnownDevice import to.bitkit.models.Toast +import to.bitkit.models.addressTypeForDerivationPath +import to.bitkit.models.toAccountType import to.bitkit.models.toCoreNetwork import to.bitkit.models.toTrezorCoinType import to.bitkit.repositories.TrezorRepo @@ -684,9 +686,21 @@ class TrezorViewModel @Inject constructor( _uiState.update { it.copy(watcher = it.watcher.copy(selectedAccountType = type)) } } + /** + * Copies the last fetched xpub into the watcher and selects the account type of its derivation + * path, since a normalized xpub/tpub would otherwise be detected as legacy. + */ fun populateWatcherFromXpub() { - val xpub = trezorRepo.state.value.lastPublicKey?.xpub ?: return - _uiState.update { it.copy(watcher = it.watcher.copy(extendedKey = xpub)) } + val publicKey = trezorRepo.state.value.lastPublicKey ?: return + val accountType = addressTypeForDerivationPath(publicKey.path)?.toAccountType() + _uiState.update { + it.copy( + watcher = it.watcher.copy( + extendedKey = publicKey.xpub, + selectedAccountType = accountType ?: it.watcher.selectedAccountType, + ) + ) + } } fun startWatcher() { diff --git a/app/src/test/java/to/bitkit/models/TrezorPublicKeyTest.kt b/app/src/test/java/to/bitkit/models/TrezorPublicKeyTest.kt new file mode 100644 index 0000000000..d95984e599 --- /dev/null +++ b/app/src/test/java/to/bitkit/models/TrezorPublicKeyTest.kt @@ -0,0 +1,96 @@ +package to.bitkit.models + +import com.synonym.bitkitcore.AddressType +import com.synonym.bitkitcore.TrezorPublicKeyResponse +import org.junit.Test +import kotlin.test.assertEquals +import kotlin.test.assertNull + +/** Fixtures are the BIP-44/49/84/86 test vectors for the "abandon ... about" mnemonic. */ +class TrezorPublicKeyTest { + + companion object Fixtures { + private const val LEGACY_XPUB = + "xpub6BosfCnifzxcFwrSzQiqu2DBVTshkCXacvNsWGYJVVhhawA7d4R" + + "5WSWGFNbi8Aw6ZRc1brxMyWMzG3DSSSSoekkudhUd9yLb6qx39T9nMdj" + private const val NESTED_YPUB = + "ypub6Ww3ibxVfGzLrAH1PNcjyAWenMTbbAosGNB6VvmSEgytSER9azL" + + "DWCxoJwW7Ke7icmizBMXrzBx9979FfaHxHcrArf3zbeJJJUZPf663zsP" + private const val NESTED_XPUB = + "xpub6C6nQwHaWbSrzs5tZ1q7m5R9cPK9eYpNMFesiXsYrgc1P8bvLLA" + + "et9JfHjYXKjToD8cBRswJXXbbFpXgwsswVPAZzKMa1jUp2kVkGVUaJa7" + private const val NATIVE_ZPUB = + "zpub6rFR7y4Q2AijBEqTUquhVz398htDFrtymD9xYYfG1m4wAcvPhXN" + + "fE3EfH1r1ADqtfSdVCToUG868RvUUkgDKf31mGDtKsAYz2oz2AGutZYs" + private const val NATIVE_XPUB = + "xpub6CatWdiZiodmUeTDp8LT5or8nmbKNcuyvz7WyksVFkKB4RHwCD3" + + "XyuvPEbvqAQY3rAPshWcMLoP2fMFMKHPJ4ZeZXYVUhLv1VMrjPC7PW6V" + private const val TAPROOT_XPUB = + "xpub6BgBgsespWvERF3LHQu6CnqdvfEvtMcQjYrcRzx53QJjSxarj2a" + + "fYWcLteoGVky7D3UKDP9QyrLprQ3VCECoY49yfdDEHGCtMMj92pReUsQ" + private const val TAPROOT_DESCRIPTOR = "tr([73c5da0a/86'/0'/0']$TAPROOT_XPUB/<0;1>/*)" + } + + @Test + fun `segwit accounts keep the firmware slip132 key`() { + val nested = response(xpub = NESTED_XPUB, xpubSegwit = NESTED_YPUB, path = "m/49'/0'/0'") + val native = response(xpub = NATIVE_XPUB, xpubSegwit = NATIVE_ZPUB, path = "m/84'/0'/0'") + + assertEquals(NESTED_YPUB, nested.storedAccountKey(AddressType.P2SH)) + assertEquals(NATIVE_ZPUB, native.storedAccountKey(AddressType.P2WPKH)) + } + + @Test + fun `legacy accounts keep the xpub`() { + val legacy = response(xpub = LEGACY_XPUB, xpubSegwit = null, path = "m/44'/0'/0'") + + assertEquals(LEGACY_XPUB, legacy.storedAccountKey(AddressType.P2PKH)) + } + + @Test + fun `taproot accounts never store the descriptor`() { + val taproot = response( + xpub = TAPROOT_XPUB, + xpubSegwit = TAPROOT_DESCRIPTOR, + descriptor = TAPROOT_DESCRIPTOR, + path = "m/86'/0'/0'", + ) + + assertEquals(TAPROOT_XPUB, taproot.storedAccountKey(AddressType.P2TR)) + } + + @Test + fun `segwit accounts fall back to the xpub without a segwit form`() { + val native = response(xpub = NATIVE_XPUB, xpubSegwit = null, path = "m/84'/0'/0'") + + assertEquals(NATIVE_XPUB, native.storedAccountKey(AddressType.P2WPKH)) + } + + @Test + fun `address type follows the derivation path purpose`() { + assertEquals(AddressType.P2PKH, addressTypeForDerivationPath("m/44'/0'/0'")) + assertEquals(AddressType.P2SH, addressTypeForDerivationPath("m/49'/1'/0'")) + assertEquals(AddressType.P2WPKH, addressTypeForDerivationPath("m/84'/1'/0'")) + assertEquals(AddressType.P2TR, addressTypeForDerivationPath("m/86h/0h/0h")) + assertNull(addressTypeForDerivationPath("m/45'/0'/0'")) + assertNull(addressTypeForDerivationPath("84'/0'/0'")) + } + + private fun response( + xpub: String, + xpubSegwit: String?, + path: String, + descriptor: String? = null, + ) = TrezorPublicKeyResponse( + xpub = xpub, + xpubSegwit = xpubSegwit, + descriptor = descriptor, + displayablePublicKey = xpubSegwit ?: xpub, + path = path, + publicKey = "02", + chainCode = "00", + fingerprint = 0u, + depth = 3u, + rootFingerprint = 0x73c5da0au, + ) +} diff --git a/app/src/test/java/to/bitkit/repositories/PaykitPaymentProofRepoTest.kt b/app/src/test/java/to/bitkit/repositories/PaykitPaymentProofRepoTest.kt index 965371171c..1b3090e299 100644 --- a/app/src/test/java/to/bitkit/repositories/PaykitPaymentProofRepoTest.kt +++ b/app/src/test/java/to/bitkit/repositories/PaykitPaymentProofRepoTest.kt @@ -515,7 +515,7 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { ) } whenever(paykitSdkService.paymentRequests()).thenReturn(listOf(record)) - whenever(paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull())) + whenever(paykitSdkService.submitPaymentProof(any(), any(), any(), any(), any(), isNull(), isNull())) .thenReturn(record) val lightning = readyLightningProof(PAYMENT_REQUEST_ID) val onchain = lightning.copy( @@ -545,6 +545,7 @@ class PaykitPaymentProofRepoTest : BaseUnitTest(StandardTestDispatcher()) { paymentEndpointIdentifier = eq(proof.paymentEndpointIdentifier), proofJson = any(), billingPeriod = isNull(), + conversionQuoteId = isNull(), ) } } diff --git a/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoSubscriptionTest.kt b/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoSubscriptionTest.kt index 83d6625da4..1a28441190 100644 --- a/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoSubscriptionTest.kt +++ b/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoSubscriptionTest.kt @@ -1171,7 +1171,10 @@ class PaykitPaymentRequestRepoSubscriptionTest : BaseUnitTest(StandardTestDispat sut.refresh().getOrThrow() - assertTrue(sut.pendingRequests.value.all { !it.payment(PaykitAsset.BTC, clock.now()).isValid(clock.now()) }) + assertTrue(sut.pendingRequests.value.all { it.isPaymentDeadlineExpired(clock.now()) }) + val unpaid = requireNotNull(sut.subscriptions.value.single { it.isPayer }.paymentDueOnAcceptance(clock.now())) + assertTrue(unpaid.isPaymentDeadlineExpired(clock.now())) + assertTrue(!unpaid.payment(PaykitAsset.BTC, clock.now()).isValid(clock.now())) assertEquals(2, sut.subscriptions.value.size) sut.subscriptions.value.forEach { subscription -> assertEquals(1, subscription.paidPeriods.size) diff --git a/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoTest.kt b/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoTest.kt index b36e98f512..b3fecce4d0 100644 --- a/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoTest.kt +++ b/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoTest.kt @@ -1139,7 +1139,7 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) { sut.refresh().getOrThrow() - assertEquals(listOf("incoming", "deadline-PROPOSED"), sut.pendingRequests.value.map { it.paymentRequestId }) + assertEquals(listOf("incoming"), sut.pendingRequests.value.map { it.paymentRequestId }) assertEquals( setOf( "incoming", "accepted", "rejected", "expired", "outgoing", "unsupported", diff --git a/app/src/test/java/to/bitkit/repositories/PaykitUsdtPaymentRepoTest.kt b/app/src/test/java/to/bitkit/repositories/PaykitUsdtPaymentRepoTest.kt index c500ef16ac..0bd1440fd4 100644 --- a/app/src/test/java/to/bitkit/repositories/PaykitUsdtPaymentRepoTest.kt +++ b/app/src/test/java/to/bitkit/repositories/PaykitUsdtPaymentRepoTest.kt @@ -42,6 +42,7 @@ import org.mockito.kotlin.mock import org.mockito.kotlin.verify import org.mockito.kotlin.whenever import to.bitkit.data.keychain.Keychain +import to.bitkit.ext.runSuspendCatching import to.bitkit.models.PaykitAmount import to.bitkit.models.PaykitAsset import to.bitkit.models.PaykitRequestPricing @@ -133,6 +134,15 @@ class PaykitUsdtPaymentRepoTest : BaseUnitTest() { } } + private suspend fun stubSend(result: Result) { + whenever(usdt.send(any(), any())).doSuspendableAnswer { invocation -> + runSuspendCatching { + invocation.getArgument Unit>(1).invoke() + result.getOrThrow() + } + } + } + private fun repo() = PaykitUsdtPaymentRepo(testDispatcher, keychain, sdk, proofs, usdt, clock) private fun context(request: PaykitPaymentRequest = this.request) = ContactPaymentContext( @@ -153,7 +163,7 @@ class PaykitUsdtPaymentRepoTest : BaseUnitTest() { val repo = repo() repo.prepare(context(recurring), quote, amount, recurring.payment(PaykitAsset.USDT, clock.now())).getOrThrow() assertTrue(repo.protectedRequestIdsForSubscriptionCancellation(identity, subscription).getOrThrow().isEmpty()) - whenever(usdt.send(quote)).thenReturn(Result.success(mock())) + stubSend(Result.success(mock())) repo.send(quote) { assertEquals( setOf(recurring.id), @@ -198,12 +208,12 @@ class PaykitUsdtPaymentRepoTest : BaseUnitTest() { } @Test - fun `execution authorization failure never dispatches and releases an unsubmitted attempt`() = test { + fun `execution authorization failure releases an unsubmitted attempt`() = test { val repo = repo() repo.prepare(context(), quote, amount, request.payment(PaykitAsset.USDT, clock.now())).getOrThrow() + stubSend(Result.success(mock())) val result = repo.send(quote) { throw PaykitPaymentRequestError.RequestUnavailable } assertTrue(result.isFailure) - org.mockito.kotlin.verify(usdt, org.mockito.kotlin.never()).send(any()) assertEquals(false, repo.attempts.value.single().paymentStarted) } @@ -242,7 +252,7 @@ class PaykitUsdtPaymentRepoTest : BaseUnitTest() { val original = repo() original.prepare(context(), quote, amount, request.payment(PaykitAsset.USDT, clock.now())).getOrThrow() val unstartedState = stored - whenever(usdt.send(quote)).thenReturn(Result.success(mock())) + stubSend(Result.success(mock())) original.send(quote).getOrThrow() val backup = original.backupSnapshot() for (localState in listOf(null, unstartedState)) { @@ -275,7 +285,7 @@ class PaykitUsdtPaymentRepoTest : BaseUnitTest() { stored = null val repo = repo() stubStoredTransfer(history) - whenever(usdt.send(quote)).thenReturn(Result.failure(UsdtException.QuoteExpired())) + stubSend(Result.failure(UsdtException.QuoteExpired())) repo.prepare(context(), quote, amount, request.payment(PaykitAsset.USDT, clock.now())).getOrThrow() assertTrue(repo.send(quote).isFailure) val replacement = repo.prepare( diff --git a/app/src/test/java/to/bitkit/repositories/PrivatePaykitRepoTest.kt b/app/src/test/java/to/bitkit/repositories/PrivatePaykitRepoTest.kt index 240f10b6c3..a4c5c8cce4 100644 --- a/app/src/test/java/to/bitkit/repositories/PrivatePaykitRepoTest.kt +++ b/app/src/test/java/to/bitkit/repositories/PrivatePaykitRepoTest.kt @@ -3397,7 +3397,7 @@ class PrivatePaykitRepoTest : BaseUnitTest(StandardTestDispatcher()) { @Test fun `backupSnapshot and restoreBackup use SDK backup state`() = test { val backup = "sdk-backup" - whenever(paykitSdkService.exportBackupState()).thenReturn(backup) + whenever(paykitSdkService.exportBackupState(Priority.Interactive)).thenReturn(backup) sut.consumePrivatePaymentList( CONTACT_KEY, PrivatePaykitPaymentContext(mapOf(MethodId.Bolt11.rawValue to "bitkit"), 7uL), diff --git a/app/src/test/java/to/bitkit/repositories/TrezorRepoTest.kt b/app/src/test/java/to/bitkit/repositories/TrezorRepoTest.kt index efb6c33d26..b2c66c6a53 100644 --- a/app/src/test/java/to/bitkit/repositories/TrezorRepoTest.kt +++ b/app/src/test/java/to/bitkit/repositories/TrezorRepoTest.kt @@ -45,6 +45,7 @@ import to.bitkit.models.HwWalletVendor import to.bitkit.models.KnownDevice import to.bitkit.models.TransportType import to.bitkit.models.toCoreNetwork +import to.bitkit.models.walletKey import to.bitkit.services.TrezorService import to.bitkit.services.TrezorTransport import to.bitkit.services.TrezorUiHandler @@ -163,21 +164,32 @@ class TrezorRepoTest : BaseUnitTest() { on { this.unlocked }.thenReturn(unlocked) } + /** + * A response shaped like bitkit-core 0.7.0 returns it for an account whose key Core 0.5.18 returned, + * and the store persisted, as [storedKey]: SegWit accounts carry it in `xpubSegwit` next to a + * normalized `xpub`, and Taproot adds a descriptor that must never be stored. + */ private fun mockPublicKeyResponse( - xpub: String, + storedKey: String, path: String, - ) = TrezorPublicKeyResponse( - xpub = xpub, - xpubSegwit = null, - descriptor = null, - displayablePublicKey = xpub, - path = path, - publicKey = "pubkey", - chainCode = "chaincode", - fingerprint = 0u, - depth = 3u, - rootFingerprint = 0u, - ) + ): TrezorPublicKeyResponse { + val purpose = path.split("/").getOrNull(1) + val isSegwit = purpose == "49'" || purpose == "84'" + val descriptor = "tr([00000000/86'/1'/0']$storedKey/<0;1>/*)".takeIf { purpose == "86'" } + val xpubSegwit = if (isSegwit) storedKey else descriptor + return TrezorPublicKeyResponse( + xpub = if (isSegwit) "normalized-$storedKey" else storedKey, + xpubSegwit = xpubSegwit, + descriptor = descriptor, + displayablePublicKey = xpubSegwit ?: storedKey, + path = path, + publicKey = "pubkey", + chainCode = "chaincode", + fingerprint = 0u, + depth = 3u, + rootFingerprint = 0u, + ) + } private fun stubAccountXpubFetch() { whenever { @@ -188,7 +200,7 @@ class TrezorRepoTest : BaseUnitTest() { ) }.thenAnswer { mockPublicKeyResponse( - xpub = "xpub-${it.getArgument(0)}", + storedKey = "xpub-${it.getArgument(0)}", path = it.getArgument(0), ) } @@ -760,7 +772,7 @@ class TrezorRepoTest : BaseUnitTest() { ).thenAnswer { val path = it.getArgument(0) if (path == nativeSegwitPath) { - mockPublicKeyResponse(xpub = "same-native-xpub", path = nativeSegwitPath) + mockPublicKeyResponse(storedKey = "same-native-xpub", path = nativeSegwitPath) } else { throw AppError("xpub failed") } @@ -825,7 +837,7 @@ class TrezorRepoTest : BaseUnitTest() { whenever(trezorService.scan()).thenReturn(listOf(mockDeviceInfo())) whenever( trezorService.getPublicKey(path = any(), coin = anyOrNull(), showOnTrezor = eq(false)) - ).thenAnswer { mockPublicKeyResponse(xpub = sharedKey, path = it.getArgument(0)) } + ).thenAnswer { mockPublicKeyResponse(storedKey = sharedKey, path = it.getArgument(0)) } sut = createSut() sut.scan() @@ -856,7 +868,7 @@ class TrezorRepoTest : BaseUnitTest() { whenever(trezorService.scan()).thenReturn(listOf(mockDeviceInfo())) whenever( trezorService.getPublicKey(path = any(), coin = anyOrNull(), showOnTrezor = eq(false)) - ).thenAnswer { mockPublicKeyResponse(xpub = sharedKey, path = it.getArgument(0)) } + ).thenAnswer { mockPublicKeyResponse(storedKey = sharedKey, path = it.getArgument(0)) } sut = createSut() sut.scan() @@ -890,7 +902,7 @@ class TrezorRepoTest : BaseUnitTest() { whenever(trezorService.scan()).thenReturn(listOf(mockDeviceInfo())) whenever( trezorService.getPublicKey(path = any(), coin = anyOrNull(), showOnTrezor = eq(false)) - ).thenAnswer { mockPublicKeyResponse(xpub = sharedKey, path = it.getArgument(0)) } + ).thenAnswer { mockPublicKeyResponse(storedKey = sharedKey, path = it.getArgument(0)) } sut = createSut() sut.scan() @@ -924,7 +936,7 @@ class TrezorRepoTest : BaseUnitTest() { whenever(trezorService.scan()).thenReturn(listOf(mockDeviceInfo())) whenever( trezorService.getPublicKey(path = any(), coin = anyOrNull(), showOnTrezor = eq(false)) - ).thenAnswer { mockPublicKeyResponse(xpub = sharedKey, path = it.getArgument(0)) } + ).thenAnswer { mockPublicKeyResponse(storedKey = sharedKey, path = it.getArgument(0)) } sut = createSut() sut.scan() @@ -1076,7 +1088,7 @@ class TrezorRepoTest : BaseUnitTest() { ).thenAnswer { val path = it.getArgument(0) if (path == nativeSegwitPath) { - mockPublicKeyResponse(xpub = "native-xpub", path = nativeSegwitPath) + mockPublicKeyResponse(storedKey = "native-xpub", path = nativeSegwitPath) } else { throw AppError("xpub failed") } @@ -1098,6 +1110,61 @@ class TrezorRepoTest : BaseUnitTest() { ) } + @Test + fun `connect stores the account keys in the form core 0_5_18 returned them`() = test { + // Core 0.7.0 normalizes `xpub`; storing it would change the wallet key and derived wallet id. + val features = mockFeatures() + whenever(trezorService.connect(eq(DEVICE_ID), any())).thenReturn(features) + whenever(trezorService.scan()).thenReturn(listOf(mockDeviceInfo())) + sut = createSut() + + sut.scan() + val result = sut.connect(DEVICE_ID) + + assertTrue(result.isSuccess) + val captor = argumentCaptor>() + verify(hwWalletStore).saveKnownDevices(captor.capture(), anyOrNull(), eq(HwWalletVendor.TREZOR)) + assertEquals( + mapOf( + "legacy" to "xpub-m/44'/1'/0'", + "nestedSegwit" to "xpub-m/49'/1'/0'", + "nativeSegwit" to "xpub-m/84'/1'/0'", + "taproot" to "xpub-m/86'/1'/0'", + ), + captor.firstValue.single().xpubs, + ) + } + + @Test + fun `connect keeps the identity of a device paired before core 0_7_0`() = test { + val pairedBefore = mockKnownDevice( + xpubs = mapOf( + "legacy" to "xpub-m/44'/1'/0'", + "nestedSegwit" to "xpub-m/49'/1'/0'", + "nativeSegwit" to "xpub-m/84'/1'/0'", + "taproot" to "xpub-m/86'/1'/0'", + ), + customLabel = "Savings", + ) + val features = mockFeatures() + whenever(hwWalletStore.loadKnownDevices(HwWalletVendor.TREZOR)).thenReturn(listOf(pairedBefore)) + whenever(trezorService.connect(eq(DEVICE_ID), any())).thenReturn(features) + whenever(trezorService.scan()).thenReturn(listOf(mockDeviceInfo())) + sut = createSut() + + sut.scan() + val result = sut.connect(DEVICE_ID) + + assertTrue(result.isSuccess) + val captor = argumentCaptor>() + verify(hwWalletStore).saveKnownDevices(captor.capture(), anyOrNull(), eq(HwWalletVendor.TREZOR)) + val saved = captor.firstValue.single() + assertEquals(pairedBefore.xpubs, saved.xpubs) + assertEquals(pairedBefore.walletKey, saved.walletKey) + assertEquals(pairedBefore.walletId, saved.walletId) + assertEquals("Savings", saved.customLabel) + } + @Test fun `connect preserves stored custom label over stale state label`() = test { val features = mockFeatures() @@ -1215,7 +1282,7 @@ class TrezorRepoTest : BaseUnitTest() { if (nativeSegwitAttempts == 1) { throw TrezorException.DeviceBusy() } - mockPublicKeyResponse(xpub = "native-xpub", path = nativeSegwitPath) + mockPublicKeyResponse(storedKey = "native-xpub", path = nativeSegwitPath) } else { throw AppError("unsupported") } @@ -1285,7 +1352,7 @@ class TrezorRepoTest : BaseUnitTest() { ) ).thenAnswer { if (it.getArgument(0) == nativeSegwitPath) { - mockPublicKeyResponse(xpub = "native-xpub", path = nativeSegwitPath) + mockPublicKeyResponse(storedKey = "native-xpub", path = nativeSegwitPath) } else { throw TrezorException.Timeout() } @@ -2210,7 +2277,7 @@ class TrezorRepoTest : BaseUnitTest() { whenever(trezorService.scan()).thenReturn(listOf(mockDeviceInfo())) whenever( trezorService.getPublicKey(path = any(), coin = anyOrNull(), showOnTrezor = eq(false)) - ).thenAnswer { mockPublicKeyResponse(xpub = keptKey, path = it.getArgument(0)) } + ).thenAnswer { mockPublicKeyResponse(storedKey = keptKey, path = it.getArgument(0)) } sut = createSut() sut.scan() sut.connect(DEVICE_ID) @@ -2240,7 +2307,7 @@ class TrezorRepoTest : BaseUnitTest() { whenever(trezorService.scan()).thenReturn(listOf(mockDeviceInfo())) whenever( trezorService.getPublicKey(path = any(), coin = anyOrNull(), showOnTrezor = eq(false)) - ).thenAnswer { mockPublicKeyResponse(xpub = forgottenKey, path = it.getArgument(0)) } + ).thenAnswer { mockPublicKeyResponse(storedKey = forgottenKey, path = it.getArgument(0)) } sut = createSut() sut.scan() sut.connect(DEVICE_ID) diff --git a/app/src/test/java/to/bitkit/repositories/UsdtRepoTest.kt b/app/src/test/java/to/bitkit/repositories/UsdtRepoTest.kt index 69c498b8af..9350c928bc 100644 --- a/app/src/test/java/to/bitkit/repositories/UsdtRepoTest.kt +++ b/app/src/test/java/to/bitkit/repositories/UsdtRepoTest.kt @@ -123,6 +123,36 @@ class UsdtRepoTest : BaseUnitTest() { assertTrue(repo.state.value.historyComplete) } + @Test + fun `send authorizes after queued wallet work and never dispatches expired terms`() = test { + val release = CompletableDeferred() + whenever(service.depositNetworks()).doSuspendableAnswer { + release.await() + emptyList() + } + val repo = UsdtRepo(service, testDispatcher) + val preceding = launch { UsdtDepositRepo(repo).depositNetworks().getOrThrow() } + runCurrent() + val quote: UsdtQuote = mock() + var authorized = false + var expired = false + val send = launch { + val result = repo.send(quote) { + authorized = true + if (expired) throw PaykitPaymentRequestError.RequestExpired + } + assertEquals(PaykitPaymentRequestError.RequestExpired, result.exceptionOrNull()) + } + runCurrent() + assertEquals(false, authorized) + expired = true + release.complete(Unit) + preceding.join() + send.join() + assertTrue(authorized) + verify(service, never()).send(quote) + } + @Test fun `pending submission stays successful when subsequent history is unreadable`() = test { val quote: UsdtQuote = mock() diff --git a/app/src/test/java/to/bitkit/services/PaykitSdkServiceTest.kt b/app/src/test/java/to/bitkit/services/PaykitSdkServiceTest.kt index 13371711ef..565c6b2604 100644 --- a/app/src/test/java/to/bitkit/services/PaykitSdkServiceTest.kt +++ b/app/src/test/java/to/bitkit/services/PaykitSdkServiceTest.kt @@ -661,6 +661,8 @@ class PaykitSdkServiceTest { assertFalse(backup.isCompleted) verify(sdk, never()).exportBackupString() service.linkedPeers(Priority.Interactive) + assertEquals("pending-write-backup", service.exportBackupState(Priority.Interactive)) + assertFalse(backup.isCompleted) if (cancelBackup) { backup.cancel() assertFailsWith { backup.await() } @@ -668,7 +670,7 @@ class PaykitSdkServiceTest { service.setPaymentSubmissionActive(false) runCurrent() if (!cancelBackup) assertEquals("pending-write-backup", backup.await()) - verify(sdk, times(if (cancelBackup) 0 else 1)).exportBackupString() + verify(sdk, times(if (cancelBackup) 1 else 2)).exportBackupString() } } diff --git a/app/src/test/java/to/bitkit/ui/screens/trezor/TrezorViewModelTest.kt b/app/src/test/java/to/bitkit/ui/screens/trezor/TrezorViewModelTest.kt index 7c5da8ba80..c96a2c9dc8 100644 --- a/app/src/test/java/to/bitkit/ui/screens/trezor/TrezorViewModelTest.kt +++ b/app/src/test/java/to/bitkit/ui/screens/trezor/TrezorViewModelTest.kt @@ -1,5 +1,6 @@ package to.bitkit.ui.screens.trezor +import com.synonym.bitkitcore.AccountType import com.synonym.bitkitcore.AddressInfo import com.synonym.bitkitcore.TrezorSignedTx import com.synonym.bitkitcore.WatcherEvent @@ -170,6 +171,32 @@ class TrezorViewModelTest : BaseUnitTest() { assertEquals(input, sut.uiState.value.lookupInput) } + @Test + fun `populateWatcherFromXpub should copy the xpub and select the account type of its path`() { + // Core 0.7.0 returns a normalized xpub/tpub, which prefix detection would read as legacy. + val publicKey = TrezorPreviewData.samplePublicKeyResponse + trezorStateFlow.value = TrezorState(lastPublicKey = publicKey) + + sut.populateWatcherFromXpub() + + val watcher = sut.uiState.value.watcher + assertEquals(publicKey.xpub, watcher.extendedKey) + assertEquals(AccountType.NATIVE_SEGWIT, watcher.selectedAccountType) + } + + @Test + fun `populateWatcherFromXpub should keep the selected account type for an unknown path`() { + val publicKey = TrezorPreviewData.samplePublicKeyResponse.copy(path = "m/45'/0'/0'") + trezorStateFlow.value = TrezorState(lastPublicKey = publicKey) + sut.setWatcherAccountType(AccountType.TAPROOT) + + sut.populateWatcherFromXpub() + + val watcher = sut.uiState.value.watcher + assertEquals(publicKey.xpub, watcher.extendedKey) + assertEquals(AccountType.TAPROOT, watcher.selectedAccountType) + } + // endregion // region Async methods diff --git a/app/src/test/java/to/bitkit/ui/screens/wallets/usdt/UsdtViewModelTest.kt b/app/src/test/java/to/bitkit/ui/screens/wallets/usdt/UsdtViewModelTest.kt index e3cfec247f..1a72645a30 100644 --- a/app/src/test/java/to/bitkit/ui/screens/wallets/usdt/UsdtViewModelTest.kt +++ b/app/src/test/java/to/bitkit/ui/screens/wallets/usdt/UsdtViewModelTest.kt @@ -13,6 +13,7 @@ import kotlinx.coroutines.launch import org.junit.Test import org.mockito.Mockito import org.mockito.kotlin.any +import org.mockito.kotlin.eq import org.mockito.kotlin.mock import org.mockito.kotlin.never import org.mockito.kotlin.times @@ -70,7 +71,7 @@ class UsdtViewModelTest : BaseUnitTest() { assertEquals(quote.recipient, request?.recipient) assertEquals(1_500_000uL, request?.amount) verify(repo, never()).quote(any(), any(), any(), any()) - verify(repo, never()).send(any()) + verify(repo, never()).send(any(), any()) assertNull(viewModel.state.value.error) } finally { parser.close() } } @@ -81,17 +82,17 @@ class UsdtViewModelTest : BaseUnitTest() { viewModel.quote(quote.recipient, "1", quote.destination).join() viewModel.confirm().join() assertTrue(viewModel.state.value.authenticationRequired) - verify(repo, never()).send(any()) + verify(repo, never()).send(any(), any()) viewModel.cancelAuthentication() viewModel.authenticationVerified() - verify(repo, never()).send(any()) + verify(repo, never()).send(any(), any()) viewModel.confirm().join() viewModel.authenticationVerified() viewModel.authenticationVerified() viewModel.confirm().join() - verify(repo, times(1)).send(quote) + verify(repo, times(1)).send(eq(quote), any()) assertTrue(viewModel.state.value.submitted) assertTrue(viewModel.state.value.busy) viewModel.waitForTransfer() @@ -102,7 +103,7 @@ class UsdtViewModelTest : BaseUnitTest() { fun `failed submission clears the quote and never reports success`() = test { val viewModel = createViewModel() settings.value = settings.value.copy(isPinForPaymentsEnabled = false) - whenever(repo.send(quote)).thenReturn(Result.failure(UsdtException.QuoteExpired())) + whenever(repo.send(eq(quote), any())).thenReturn(Result.failure(UsdtException.QuoteExpired())) viewModel.quote(quote.recipient, "1", quote.destination).join() viewModel.confirm().join() assertFalse(viewModel.state.value.authenticationRequired) @@ -111,7 +112,7 @@ class UsdtViewModelTest : BaseUnitTest() { assertNull(viewModel.state.value.quote) assertEquals(R.string.usdt__error_expired, viewModel.state.value.error) viewModel.confirm().join() - verify(repo, times(1)).send(quote) + verify(repo, times(1)).send(eq(quote), any()) } @Test @@ -124,7 +125,7 @@ class UsdtViewModelTest : BaseUnitTest() { viewModel.confirm().join() assertEquals(SanityWarning.VALUE_OVER_100_USD, viewModel.state.value.warning) assertFalse(viewModel.state.value.authenticationRequired) - verify(repo, never()).send(any()) + verify(repo, never()).send(any(), any()) viewModel.acceptWarning() assertNull(viewModel.state.value.warning) assertTrue(viewModel.state.value.authenticationRequired) @@ -146,7 +147,7 @@ class UsdtViewModelTest : BaseUnitTest() { viewModel.quote(replacement.recipient, "2", replacement.destination).join() delayed.emit(SettingsData(isPinEnabled = false)) confirmation.join() - verify(repo, never()).send(any()) + verify(repo, never()).send(any(), any()) assertEquals("replacement", viewModel.state.value.quote?.id) } @@ -166,13 +167,13 @@ class UsdtViewModelTest : BaseUnitTest() { assertEquals(R.string.usdt__error_storage, viewModel.state.value.error) assertFalse(viewModel.state.value.busy) assertFalse(viewModel.state.value.authenticationRequired) - verify(repo, never()).send(any()) + verify(repo, never()).send(any(), any()) failing = false viewModel.confirm().join() assertNull(viewModel.state.value.error) assertTrue(viewModel.state.value.authenticationRequired) - verify(repo, never()).send(any()) + verify(repo, never()).send(any(), any()) collector.cancel() } @@ -212,7 +213,7 @@ class UsdtViewModelTest : BaseUnitTest() { whenever(repo.state).thenReturn(MutableStateFlow(UsdtWalletState())) whenever(settingsStore.data).thenReturn(settingsFlow) whenever(repo.quote(any(), any(), any(), any())).thenReturn(Result.success(quote)) - whenever(repo.send(quote)).thenReturn(Result.success(mock())) + whenever(repo.send(eq(quote), any())).thenReturn(Result.success(mock())) whenever(repo.refresh(false)).thenReturn(Result.success(Unit)) whenever(repo.waitForTransfer(quote.id)).thenReturn(Result.success(Unit)) return UsdtViewModel(repo, settingsStore) diff --git a/app/src/test/java/to/bitkit/viewmodels/AppViewModelSendFlowTest.kt b/app/src/test/java/to/bitkit/viewmodels/AppViewModelSendFlowTest.kt index fea6b05ad2..753658f78d 100644 --- a/app/src/test/java/to/bitkit/viewmodels/AppViewModelSendFlowTest.kt +++ b/app/src/test/java/to/bitkit/viewmodels/AppViewModelSendFlowTest.kt @@ -10330,17 +10330,17 @@ class AppViewModelSendFlowTest : BaseUnitTest() { whenever(paykitPaymentRequestRepo.accept(request)).thenReturn(Result.success(Unit)) whenever(privatePaykitRepo.consumePrivatePaymentList(testPublicKey, privateContext)) .thenReturn(Result.success(Unit)) - whenever(lightningRepo.fetchLnurlInvoice(lnurl, lnurl.callbackAmountMsats(request.amountSats), null)) + whenever(lightningRepo.fetchLnurlInvoice(lnurl, lnurl.callbackAmountMsats(request.amount.atomic), null)) .doSuspendableAnswer { whenever(paykitPaymentRequestRepo.ensurePaymentAllowed(request)) .thenReturn(Result.failure(PaykitPaymentRequestError.RequestExpired)) - Result.success(lightningInvoice("lnbcrt1deadline", request.amountSats)) + Result.success(lightningInvoice("lnbcrt1deadline", request.amount.atomic)) } setActiveContactPaymentContext(testPublicKey, privateContext, request) setSendState( SendUiState( address = lnurl.uri, - amount = request.amountSats, + amount = request.amount.atomic, payMethod = SendMethod.LIGHTNING, lnurl = LnurlParams.LnurlPay(lnurl), isPaymentRequest = true, @@ -12224,7 +12224,8 @@ class AppViewModelSendFlowTest : BaseUnitTest() { sut.setSendEvent(SendEvent.PayConfirmed) advanceUntilIdle() verify(lightningRepo, never()).sendOnChain( - any(), any(), anyOrNull(), anyOrNull(), anyOrNull(), any(), anyOrNull(), any(), any(), any(), any() + any(), any(), anyOrNull(), anyOrNull(), anyOrNull(), any(), + anyOrNull(), any(), any(), any(), any(), anyOrNull() ) verify(paykitPaymentRequestRepo, never()).accept(any()) verify(paykitPaymentProofRepo, never()).prepare(any(), any(), any(), any(), anyOrNull()) diff --git a/docs/usdt.md b/docs/usdt.md index d856014765..5d0b5787ae 100644 --- a/docs/usdt.md +++ b/docs/usdt.md @@ -1,5 +1,7 @@ # USDT configuration +Normal builds use published bitkit-core `0.8.0-rc1`, including its matching native libraries and generated bindings. + USDT uses Arbitrum One regardless of the Bitcoin network setting. Gradle reads `USDT_RPC_URL` and `USDT_BUNDLER_URL` from local properties/environment configuration. Both must point to the controlled service's credential-free HTTPS chain and bundler routes. Missing endpoints hide the wallet entry. Optional `USDT_DEPOSITS_URL` enables wallet-signed Orchestra deposits. Provider keys remain on the service. Source support covers Ethereum, Tron, Solana, Polygon, Base and BNB Smart Chain, subject to explicit service enablement and live route availability. Each source requires funded acceptance before release. Users approve a source-network refund address when requesting an eligible refund; unconverted Tron refunds require provider support. History and addresses recover under the same provider partner account. Linked order amounts are batch totals. Outbound USDT0 destinations are enabled with `USDT_BRIDGE_NETWORKS`, a comma-separated subset of `ethereum,polygon,plasma,stable`, matching the service configuration. Empty configuration offers Arbitrum only. Paykit always uses direct Arbitrum payments. From 3338d0485c5d642cc621034d8eafd4312d0ce756 Mon Sep 17 00:00:00 2001 From: benk10 Date: Tue, 6 Oct 2026 22:43:27 -0500 Subject: [PATCH 03/62] chore: rename changelog fragment --- changelog.d/next/{usdt.added.md => 1432.added.md} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename changelog.d/next/{usdt.added.md => 1432.added.md} (100%) diff --git a/changelog.d/next/usdt.added.md b/changelog.d/next/1432.added.md similarity index 100% rename from changelog.d/next/usdt.added.md rename to changelog.d/next/1432.added.md From 29c2413881b4d4ad66abb1930dbf8398c2212d10 Mon Sep 17 00:00:00 2001 From: benk10 Date: Tue, 6 Oct 2026 23:27:31 -0500 Subject: [PATCH 04/62] feat: add usdt bridge support actions --- .../wallets/usdt/UsdtActivityDetail.kt | 2 + .../wallets/usdt/UsdtDepositReceiveScreen.kt | 1 + .../wallets/usdt/UsdtSupportActions.kt | 68 +++++++++++++++++++ app/src/main/res/values/strings.xml | 2 + .../wallets/usdt/UsdtSupportDetailsTest.kt | 62 +++++++++++++++++ journeys/usdt-bridge-support.xml | 12 ++++ 6 files changed, 147 insertions(+) create mode 100644 app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtSupportActions.kt create mode 100644 app/src/test/java/to/bitkit/ui/screens/wallets/usdt/UsdtSupportDetailsTest.kt create mode 100644 journeys/usdt-bridge-support.xml diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtActivityDetail.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtActivityDetail.kt index 0aa487034d..c152f03ad0 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtActivityDetail.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtActivityDetail.kt @@ -232,6 +232,7 @@ private fun paykitContactName(transferId: String): String? { @Composable private fun UsdtOrchestraDetails(bridge: com.synonym.bitkitcore.UsdtOrchestraTransfer, hideBalance: Boolean) { SendCell(caption = stringResource(R.string.usdt__bridge_provider)) { BodySSB("Orchestra") } + SendCell(caption = stringResource(R.string.usdt__bridge_reference)) { SelectionContainer { BodyS(bridge.quoteId) } } bridge.destinationTx?.let { hash -> SendCell( caption = stringResource(R.string.usdt__destination_tx) @@ -263,4 +264,5 @@ private fun UsdtTransactionDetails(transfer: UsdtTransfer) { uri.openUri("https://arbiscan.io/tx/" + txHash) }) } + if (transfer.destination != UsdtDestination.ARBITRUM) UsdtSupportActions(transfer.supportDetails) } diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtDepositReceiveScreen.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtDepositReceiveScreen.kt index 21e7b557e9..d0d7daf50a 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtDepositReceiveScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtDepositReceiveScreen.kt @@ -462,6 +462,7 @@ private fun DepositDetail( modifier = Modifier.testTag("UsdtDepositRefund") ) } + UsdtSupportActions(detail.supportDetails, enabled = !busy) } @Composable diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtSupportActions.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtSupportActions.kt new file mode 100644 index 0000000000..e7adc60cc9 --- /dev/null +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtSupportActions.kt @@ -0,0 +1,68 @@ +package to.bitkit.ui.screens.wallets.usdt + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.runtime.Composable +import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.platform.testTag +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.unit.dp +import com.synonym.bitkitcore.UsdtDepositDetail +import com.synonym.bitkitcore.UsdtTransfer +import to.bitkit.R +import to.bitkit.ext.setClipboardText +import to.bitkit.models.Toast +import to.bitkit.ui.appViewModel +import to.bitkit.ui.components.SecondaryButton + +@Composable +internal fun UsdtSupportActions(details: String, enabled: Boolean = true) { + val app = appViewModel ?: return + val context = LocalContext.current + Column(verticalArrangement = Arrangement.spacedBy(16.dp)) { + SecondaryButton( + text = stringResource(R.string.wallet__send_error_support), + onClick = { app.navigateToReportIssue(details) }, + enabled = enabled, + modifier = Modifier.testTag("UsdtContactSupport") + ) + SecondaryButton( + text = stringResource(R.string.usdt__copy_details), + onClick = { + context.setClipboardText(details) + app.toast(type = Toast.ToastType.SUCCESS, title = context.getString(R.string.common__copied)) + }, + enabled = enabled, + modifier = Modifier.testTag("UsdtCopyDetails") + ) + } +} + +internal val UsdtTransfer.supportDetails: String + get() = buildList { + add("Asset: USDT") + add("Bridge: ${if (orchestra == null) "USDT0" else "Orchestra"}") + add("Source network: Arbitrum One") + add("Recipient network: ${destination.label}") + add("Status: $status") + orchestra?.quoteId?.let { add("Bridge reference: $it") } + txHash?.let { add("Source transaction: $it") } + bridgeGuid?.let { add("LayerZero message: $it") } + orchestra?.destinationTx?.let { add("Destination transaction: $it") } + orchestra?.refundTx?.let { add("Refund transaction: $it") } + }.joinToString("\n") + +internal val UsdtDepositDetail.supportDetails: String + get() = buildList { + add("Asset: ${deposit.asset}") + add("Bridge: Orchestra") + add("Source network: ${deposit.network}") + add("Recipient network: Arbitrum One") + add("Deposit reference: ${deposit.id}") + add("Status: ${order?.status ?: deposit.status}") + add("Source transaction: ${deposit.sourceTx}") + statusCode?.let { add("Status code: $it") } + order?.destinationTx?.let { add("Destination transaction: $it") } + (order?.refundTx ?: deposit.refundTx)?.let { add("Refund transaction: $it") } + }.joinToString("\n") diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index d3da863887..f9754f57c1 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -1223,9 +1223,11 @@ Amount (USDT) Balance Bridge needs attention + Bridge reference Your payment is pending. You can track confirmation and cross-network delivery in Activity. Delivering to destination Confirmed + Copy Details Deposit amount Amount outside deposit limits. This deposit needs provider assistance. Contact Bitkit support with the deposit reference. diff --git a/app/src/test/java/to/bitkit/ui/screens/wallets/usdt/UsdtSupportDetailsTest.kt b/app/src/test/java/to/bitkit/ui/screens/wallets/usdt/UsdtSupportDetailsTest.kt new file mode 100644 index 0000000000..d0795b690b --- /dev/null +++ b/app/src/test/java/to/bitkit/ui/screens/wallets/usdt/UsdtSupportDetailsTest.kt @@ -0,0 +1,62 @@ +package to.bitkit.ui.screens.wallets.usdt + +import com.synonym.bitkitcore.UsdtDeposit +import com.synonym.bitkitcore.UsdtDepositDetail +import com.synonym.bitkitcore.UsdtDepositOrder +import com.synonym.bitkitcore.UsdtDestination +import com.synonym.bitkitcore.UsdtOrchestraTransfer +import com.synonym.bitkitcore.UsdtTransfer +import com.synonym.bitkitcore.UsdtTransferStatus +import org.junit.Test +import kotlin.test.assertFalse +import kotlin.test.assertTrue + +class UsdtSupportDetailsTest { + @Test + fun `transfer support includes provider references and transactions`() { + val transfer = UsdtTransfer( + id = "local-id", + txHash = "source-tx", + userOperationHash = null, + bridgeGuid = "message-id", + orchestra = null, + recipient = "recipient-address", + destination = UsdtDestination.POLYGON, + amount = 100u, + receivedAmount = 90u, + fee = 10u, + isIncoming = false, + status = UsdtTransferStatus.BRIDGE_NEEDS_ATTENTION, + timestamp = 1u, + ) + assertTrue(transfer.supportDetails.contains("Bridge: USDT0")) + assertTrue(transfer.supportDetails.contains("LayerZero message: message-id")) + assertFalse(transfer.supportDetails.contains("Destination transaction:")) + + val details = transfer.copy( + bridgeGuid = null, + orchestra = UsdtOrchestraTransfer("order-id", "funding-address", "destination-tx", "refund-tx", 90u), + ).supportDetails + listOf("Orchestra", "Arbitrum One", "Polygon", "order-id", "source-tx", "destination-tx", "refund-tx").forEach { + assertTrue(details.contains(it), it) + } + assertFalse(details.contains("recipient-address")) + assertFalse(details.contains("funding-address")) + } + + @Test + fun `deposit support uses current order status and refund`() { + val deposit = UsdtDeposit("deposit-id", "tron", "USDT", 100u, "source-tx", "held", "old-code", "deposit-refund") + val detail = UsdtDepositDetail(deposit, null) + assertTrue(detail.supportDetails.contains("Status code: old-code")) + assertTrue(detail.supportDetails.contains("Refund transaction: deposit-refund")) + val details = detail.copy( + order = UsdtDepositOrder("refunded", 100u, null, null, "order-refund", null), + ).supportDetails + listOf("Orchestra", "tron", "Arbitrum One", "deposit-id", "source-tx", "refunded", "order-refund").forEach { + assertTrue(details.contains(it), it) + } + assertFalse(details.contains("old-code")) + assertFalse(details.contains("deposit-refund")) + } +} diff --git a/journeys/usdt-bridge-support.xml b/journeys/usdt-bridge-support.xml new file mode 100644 index 0000000000..81167be699 --- /dev/null +++ b/journeys/usdt-bridge-support.xml @@ -0,0 +1,12 @@ + + Use an onboarded wallet with an outbound cross-network transfer and an Orchestra deposit in its history. Existing history or a provider fixture is sufficient; do not submit a payment or support request. + + Open USDT from Home, then open a cross-network transfer in Activity. + Verify the source transaction is displayed. For an Orchestra transfer, verify the bridge reference is also displayed. + Tap Copy Details (id "UsdtCopyDetails"). Verify the clipboard contains the bridge, networks, status and available transaction references. + Tap Contact Support (id "UsdtContactSupport"). Verify the report form opens with those details prefilled and remains unsent. Return without submitting. + Open USDT Receive and Cross-network Deposits, then open a deposit. + Tap Copy Details (id "UsdtCopyDetails"). Verify the clipboard includes the deposit reference, source network and source transaction, plus the current status and any destination or refund transaction. + Tap Contact Support (id "UsdtContactSupport"). Verify the receive sheet closes and the report form opens with the deposit details prefilled. Return without submitting or requesting a refund. + + From d7fe9c02ce10d6d3a8d08c257552f700737944ff Mon Sep 17 00:00:00 2001 From: benk10 Date: Wed, 7 Oct 2026 10:19:03 -0500 Subject: [PATCH 05/62] Make USDT sharing optional in companion authorization --- .../to/bitkit/models/PubkyAuthClaimCodec.kt | 16 +++++- .../java/to/bitkit/models/PubkyAuthRequest.kt | 18 +++---- .../screens/profile/PubkyAuthApprovalSheet.kt | 49 +++++++++++++------ .../profile/PubkyAuthApprovalViewModel.kt | 20 ++++++-- app/src/main/res/values/strings.xml | 5 +- .../to/bitkit/models/PubkyAuthRequestTest.kt | 13 +++++ .../profile/PubkyAuthApprovalViewModelTest.kt | 12 ++--- changelog.d/next/1432.added.md | 2 +- docs/earn-receiving-details.md | 42 ++++++---------- .../pubky-auth/share-receiving-details.xml | 7 ++- 10 files changed, 119 insertions(+), 65 deletions(-) diff --git a/app/src/main/java/to/bitkit/models/PubkyAuthClaimCodec.kt b/app/src/main/java/to/bitkit/models/PubkyAuthClaimCodec.kt index df9001b951..4a4461b6fe 100644 --- a/app/src/main/java/to/bitkit/models/PubkyAuthClaimCodec.kt +++ b/app/src/main/java/to/bitkit/models/PubkyAuthClaimCodec.kt @@ -1,6 +1,12 @@ package to.bitkit.models +import kotlinx.serialization.json.Json +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.buildJsonObject +import kotlinx.serialization.json.jsonObject +import kotlinx.serialization.json.put import java.nio.ByteBuffer +import java.util.Base64 object PubkyAuthClaimCodec { /** Size of the versioned account metadata and serialized extended public key. */ @@ -14,7 +20,7 @@ object PubkyAuthClaimCodec { fun validateAccountPayload(claim: PubkyAuthClaim, accountPayload: ByteArray) { if (claim.sharesUsdt) { - require(!claim.includesPaykitAccess && accountPayload.isNotEmpty()) { "Invalid payment-details claim" } + require(accountPayload.isNotEmpty()) { "Invalid payment-details claim" } return } if (!claim.includesWatchOnlyAccount) { @@ -40,6 +46,14 @@ object PubkyAuthClaimCodec { } require(generation != null && generation > 0uL) { "Invalid Paykit key generation" } require(secret?.size == 32) { "Invalid Paykit identity secret length" } + if (claim.sharesUsdt) { + val payload = Json.parseToJsonElement(accountPayload.decodeToString()).jsonObject.toMutableMap() + payload["paykit_access"] = buildJsonObject { + put("key_generation", Json.parseToJsonElement(generation.toString())) + put("secret", Base64.getUrlEncoder().withoutPadding().encodeToString(secret)) + } + return JsonObject(payload).toString().encodeToByteArray() + } val prefix = if (claim.includesWatchOnlyAccount) accountPayload else byteArrayOf(1) val length = if (claim.includesWatchOnlyAccount) COMBINED_PAYLOAD_LENGTH else PAYKIT_PAYLOAD_LENGTH return ByteBuffer.allocate(length) diff --git a/app/src/main/java/to/bitkit/models/PubkyAuthRequest.kt b/app/src/main/java/to/bitkit/models/PubkyAuthRequest.kt index a632b75910..ddab9391d0 100644 --- a/app/src/main/java/to/bitkit/models/PubkyAuthRequest.kt +++ b/app/src/main/java/to/bitkit/models/PubkyAuthRequest.kt @@ -28,28 +28,30 @@ value class PubkyAuthClaim private constructor(val items: ImmutableList) { PAYKIT_ACCESS_V1("paykit-access-v1"), WATCH_ONLY_ACCOUNT_V1("watch-only-account-v1"), USDT_ADDRESS_V1("usdt-address-v1"), - PAYMENT_DETAILS_V1("payment-details-v1"), } val wireValue: String get() = items.joinToString(".") { it.wireValue } val includesWatchOnlyAccount: Boolean - get() = Item.WATCH_ONLY_ACCOUNT_V1 in items || Item.PAYMENT_DETAILS_V1 in items + get() = Item.WATCH_ONLY_ACCOUNT_V1 in items val includesPaykitAccess: Boolean get() = Item.PAYKIT_ACCESS_V1 in items val sharesBitcoin: Boolean get() = includesWatchOnlyAccount - val sharesUsdt: Boolean get() = Item.USDT_ADDRESS_V1 in items || Item.PAYMENT_DETAILS_V1 in items + val sharesUsdt: Boolean get() = Item.USDT_ADDRESS_V1 in items val sharesReceivingDetails: Boolean get() = sharesBitcoin || sharesUsdt fun unsignedPayload(bitcoin: PreparedWatchOnlyAccountClaim?, usdt: Endpoint?): ByteArray { if (sharesBitcoin && bitcoin == null) throw PubkyAuthRequestError.InvalidPaymentDetails if (!sharesUsdt) return bitcoin?.payload ?: byteArrayOf() - if (usdt == null || usdt.methodId != MethodId.UsdtArbitrum || - PaykitUsdt.address(usdt.rawPayload) != usdt.value + if ( + usdt != null && ( + usdt.methodId != MethodId.UsdtArbitrum || + PaykitUsdt.address(usdt.rawPayload) != usdt.value + ) ) { throw PubkyAuthRequestError.InvalidPaymentDetails } return buildJsonObject { - put(MethodId.UsdtArbitrum.rawValue, Json.parseToJsonElement(usdt.rawPayload).jsonObject) + usdt?.let { put(MethodId.UsdtArbitrum.rawValue, Json.parseToJsonElement(it.rawPayload).jsonObject) } if (sharesBitcoin) { val account = checkNotNull(bitcoin).account put( @@ -66,7 +68,7 @@ value class PubkyAuthClaim private constructor(val items: ImmutableList) { companion object { val USDT_ADDRESS_V1 = PubkyAuthClaim(Item.USDT_ADDRESS_V1) - val PAYMENT_DETAILS_V1 = PubkyAuthClaim(Item.PAYMENT_DETAILS_V1) + val BITCOIN_AND_USDT = PubkyAuthClaim(Item.WATCH_ONLY_ACCOUNT_V1, Item.USDT_ADDRESS_V1) /** Query parameter used for Bitkit-specific Pubky auth claims. */ const val QUERY_PARAMETER = "x-bitkit-claim" @@ -84,8 +86,6 @@ value class PubkyAuthClaim private constructor(val items: ImmutableList) { Item.entries.firstOrNull { it.wireValue == token } ?: return null } if (items.distinct().size != items.size) return null - val hasStandaloneClaim = items.any { it == Item.USDT_ADDRESS_V1 || it == Item.PAYMENT_DETAILS_V1 } - if (items.size != 1 && hasStandaloneClaim) return null return PubkyAuthClaim(items.toImmutableList()) } } diff --git a/app/src/main/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalSheet.kt b/app/src/main/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalSheet.kt index 5bcc774d4b..e9dc592d14 100644 --- a/app/src/main/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalSheet.kt +++ b/app/src/main/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalSheet.kt @@ -63,6 +63,7 @@ import to.bitkit.ui.components.SecondaryButton import to.bitkit.ui.components.SheetSize import to.bitkit.ui.components.Text13Up import to.bitkit.ui.components.VerticalSpacer +import to.bitkit.ui.components.settings.SettingsSwitchRow import to.bitkit.ui.scaffold.SheetTopBar import to.bitkit.ui.settingsViewModel import to.bitkit.ui.shared.modifiers.sheetHeight @@ -106,6 +107,7 @@ fun PubkyAuthApprovalSheet( if (uiState.authUrl == authUrl) viewModel.returnToWatchOnlyConsent(authUrl) }, onRetryUsdt = { viewModel.loadUsdtAddress(authUrl) }, + onShareUsdt = viewModel::setShareUsdt, onCancel = { viewModel.dismiss() }, onDismiss = { viewModel.dismiss() }, ) @@ -221,6 +223,7 @@ private fun Content( onCancel: () -> Unit, onDismiss: () -> Unit, onRetryUsdt: () -> Unit = {}, + onShareUsdt: (Boolean) -> Unit = {}, ) { val approvalState = if (isCurrentRequest) uiState.state else ApprovalState.Loading val headerTitle = approvalHeaderTitle(approvalState) @@ -252,6 +255,7 @@ private fun Content( uiState = uiState, onAuthorize = onAuthorize, onRetryUsdt = onRetryUsdt, + onShareUsdt = onShareUsdt, onCancel = onCancel, ) ApprovalState.Authenticating, ApprovalState.Authorizing -> AuthorizingContent( @@ -315,21 +319,24 @@ private fun ColumnScope.WatchOnlyConsentContent( Display( text = stringResource( - when (claim) { - PubkyAuthClaim.USDT_ADDRESS_V1 -> R.string.profile__auth_approval_usdt_intro_title - PubkyAuthClaim.PAYMENT_DETAILS_V1 -> R.string.profile__auth_approval_payment_details_intro_title + when { + claim?.sharesUsdt == true && !claim.sharesBitcoin -> + R.string.profile__auth_approval_usdt_intro_title + claim?.sharesUsdt == true && claim.sharesBitcoin -> + R.string.profile__auth_approval_payment_details_intro_title else -> R.string.profile__auth_approval_watch_only_intro_title } ).withAccent( - accentColor = if (claim == PubkyAuthClaim.USDT_ADDRESS_V1) Colors.Green else Colors.Blue + accentColor = if (claim?.sharesUsdt == true && !claim.sharesBitcoin) Colors.Green else Colors.Blue ), ) VerticalSpacer(8.dp) BodyM( text = stringResource( - when (claim) { - PubkyAuthClaim.USDT_ADDRESS_V1 -> R.string.profile__auth_approval_usdt_intro_description - PubkyAuthClaim.PAYMENT_DETAILS_V1 -> + when { + claim?.sharesUsdt == true && !claim.sharesBitcoin -> + R.string.profile__auth_approval_usdt_intro_description + claim?.sharesUsdt == true && claim.sharesBitcoin -> R.string.profile__auth_approval_payment_details_intro_description else -> R.string.profile__auth_approval_watch_only_intro_description } @@ -375,10 +382,11 @@ private fun ColumnScope.LoadingContent() { private fun ColumnScope.AuthorizeContent( uiState: PubkyAuthApprovalUiState, onRetryUsdt: () -> Unit, + onShareUsdt: (Boolean) -> Unit, onAuthorize: () -> Unit, onCancel: () -> Unit, ) { - ApprovalDetails(uiState = uiState, onRetryUsdt = onRetryUsdt) + ApprovalDetails(uiState = uiState, onRetryUsdt = onRetryUsdt, onShareUsdt = onShareUsdt) Row(horizontalArrangement = Arrangement.spacedBy(16.dp)) { SecondaryButton( @@ -422,6 +430,7 @@ private fun ColumnScope.AuthorizingContent( private fun ColumnScope.ApprovalDetails( uiState: PubkyAuthApprovalUiState, onRetryUsdt: (() -> Unit)? = null, + onShareUsdt: ((Boolean) -> Unit)? = null, ) { BoxWithConstraints(modifier = Modifier.weight(1f)) { Column( @@ -442,7 +451,7 @@ private fun ColumnScope.ApprovalDetails( VerticalSpacer(32.dp) } if (uiState.bitkitClaim?.sharesReceivingDetails == true) { - PaymentDetailsSection(uiState, onRetryUsdt) + PaymentDetailsSection(uiState, onRetryUsdt, onShareUsdt) VerticalSpacer(24.dp) } if (uiState.permissions.isNotEmpty()) { @@ -508,12 +517,12 @@ private fun ColumnScope.SuccessContent( modifier = Modifier.padding(horizontal = 16.dp, vertical = 16.dp) ) - uiState.bitkitClaim?.takeIf { it.sharesReceivingDetails }?.let { claim -> + uiState.bitkitClaim?.takeIf { it.sharesBitcoin || (it.sharesUsdt && uiState.shareUsdt) }?.let { claim -> BodyM( text = stringResource( - when (claim) { - PubkyAuthClaim.USDT_ADDRESS_V1 -> R.string.profile__auth_approval_shared_usdt - PubkyAuthClaim.PAYMENT_DETAILS_V1 -> R.string.profile__auth_approval_shared_both + when { + !claim.sharesBitcoin -> R.string.profile__auth_approval_shared_usdt + claim.sharesUsdt && uiState.shareUsdt -> R.string.profile__auth_approval_shared_both else -> R.string.profile__auth_approval_shared_bitcoin } ), @@ -544,7 +553,11 @@ private fun ColumnScope.SuccessContent( } @Composable -private fun PaymentDetailsSection(uiState: PubkyAuthApprovalUiState, onRetryUsdt: (() -> Unit)?) { +private fun PaymentDetailsSection( + uiState: PubkyAuthApprovalUiState, + onRetryUsdt: (() -> Unit)?, + onShareUsdt: ((Boolean) -> Unit)?, +) { Text13Up(text = stringResource(R.string.profile__auth_approval_payment_details), color = Colors.White64) VerticalSpacer(12.dp) if (uiState.bitkitClaim?.sharesBitcoin == true) { @@ -557,7 +570,13 @@ private fun PaymentDetailsSection(uiState: PubkyAuthApprovalUiState, onRetryUsdt } if (uiState.bitkitClaim?.sharesUsdt == true) { Column(modifier = Modifier.testTag("PubkyAuthUsdtDetails")) { - BodySSB(text = "USDT · Arbitrum One", color = Colors.Green) + SettingsSwitchRow( + title = stringResource(R.string.profile__auth_approval_share_usdt_optional), + isChecked = uiState.shareUsdt, + onClick = { onShareUsdt?.invoke(!uiState.shareUsdt) }, + enabled = onShareUsdt != null, + switchTestTag = "PubkyAuthShareUsdt", + ) VerticalSpacer(8.dp) uiState.usdtAddress?.let { address -> var expanded by remember(address) { mutableStateOf(false) } diff --git a/app/src/main/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalViewModel.kt b/app/src/main/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalViewModel.kt index 5ecc609fdd..6a26664eb0 100644 --- a/app/src/main/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalViewModel.kt +++ b/app/src/main/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalViewModel.kt @@ -100,13 +100,26 @@ class PubkyAuthApprovalViewModel @Inject constructor( } } + fun setShareUsdt(enabled: Boolean) { + if (_uiState.value.state != ApprovalState.Authorize) return + _uiState.update { it.copy(shareUsdt = enabled) } + } + fun loadUsdtAddress(authUrl: String) { if (_uiState.value.authUrl != authUrl || _uiState.value.bitkitClaim?.sharesUsdt != true) return _uiState.update { it.copy(usdtAddress = null, usdtUnavailable = false) } viewModelScope.launch { val address = usdtRepo.paymentEndpoint().getOrNull()?.value _uiState.update { - if (it.authUrl == authUrl) it.copy(usdtAddress = address, usdtUnavailable = address == null) else it + if (it.authUrl == authUrl) { + it.copy( + usdtAddress = address, + usdtUnavailable = address == null, + shareUsdt = it.shareUsdt && address != null, + ) + } else { + it + } } } } @@ -276,7 +289,7 @@ class PubkyAuthApprovalViewModel @Inject constructor( } private suspend fun validatedUsdtEndpoint(request: PubkyAuthRequest): Endpoint? { - if (request.bitkitClaim?.sharesUsdt != true) return null + if (request.bitkitClaim?.sharesUsdt != true || !_uiState.value.shareUsdt) return null return usdtRepo.paymentEndpoint().getOrThrow().also { if (it.value != _uiState.value.usdtAddress) throw PubkyAuthRequestError.InvalidPaymentDetails } @@ -376,8 +389,9 @@ data class PubkyAuthApprovalUiState( val profile: PubkyProfile? = null, val usdtAddress: String? = null, val usdtUnavailable: Boolean = false, + val shareUsdt: Boolean = true, ) { - val canAuthorize: Boolean get() = bitkitClaim?.sharesUsdt != true || usdtAddress != null + val canAuthorize: Boolean get() = bitkitClaim?.sharesUsdt != true || !shareUsdt || usdtAddress != null } sealed interface ApprovalState { diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index f9754f57c1..ae99432d92 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -661,7 +661,7 @@ Separate watch-only account · xpub Paykit access PAYMENT DETAILS TO SHARE - Share a separate Bitcoin account and your existing USDT address to receive earnings. Sharing these details does not let the service spend your funds. + Share a separate Bitcoin account to receive earnings. You can also share your existing USDT address. Sharing these details does not let the service spend your funds. <accent>EARN BITCOIN\nAND USDT</accent>\nFROM YOUR CONTENT Requested permissions A service is requesting permission to access and edit your <accent>%1$s</accent> data. @@ -679,7 +679,7 @@ <accent>EARN USDT</accent>\nFROM YOUR\nCONTENT Loading USDT address… This is your existing USDT account. The service can see its balance and transaction history, but cannot spend your funds. - Your USDT address is unavailable. Try again before authorizing. + Your USDT address is unavailable. You can retry or continue without sharing it. %1$s server Approve To earn, you need to share a watch-only Bitcoin account with Paykit. It can view sales activity, but cannot spend funds. @@ -1712,4 +1712,5 @@ USDT was returned to your wallet. See details for the refunded amount. Destination transaction Refund transaction + Share USDT address (optional) diff --git a/app/src/test/java/to/bitkit/models/PubkyAuthRequestTest.kt b/app/src/test/java/to/bitkit/models/PubkyAuthRequestTest.kt index be84f8f4d1..de08acda91 100644 --- a/app/src/test/java/to/bitkit/models/PubkyAuthRequestTest.kt +++ b/app/src/test/java/to/bitkit/models/PubkyAuthRequestTest.kt @@ -12,6 +12,19 @@ import kotlin.test.assertTrue class PubkyAuthRequestTest { + @Test + fun `optional USDT omission preserves delegated Paykit authority`() { + val claim = requireNotNull(PubkyAuthClaim.fromWireValue("paykit-access-v1.usdt-address-v1")) + val payload = PubkyAuthClaimCodec.encode(claim, "{}".encodeToByteArray(), 3uL, ByteArray(32) { 11 }) + val actual = kotlinx.serialization.json.Json.parseToJsonElement(payload.decodeToString()) + val expected = kotlinx.serialization.json.Json.parseToJsonElement( + """{"paykit_access":{"key_generation":3,"secret":"CwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCws"}}""" + ) + assertEquals(expected, actual) + assertTrue(claim.sharesUsdt) + assertFalse(claim.sharesBitcoin) + } + @Test fun `parse preserves each companion selection and received item order`() { val expected = mapOf( diff --git a/app/src/test/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalViewModelTest.kt b/app/src/test/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalViewModelTest.kt index 33b68e0aee..ef11576115 100644 --- a/app/src/test/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalViewModelTest.kt +++ b/app/src/test/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalViewModelTest.kt @@ -884,7 +884,7 @@ class PubkyAuthApprovalViewModelTest : BaseUnitTest() { .thenReturn(UsdtPaymentRequest(address, null, null)) val endpoint = PaykitUsdt.endpoint(address) whenever(usdtRepo.paymentEndpoint()).thenReturn(Result.success(endpoint)) - for (claim in listOf(PubkyAuthClaim.USDT_ADDRESS_V1, PubkyAuthClaim.PAYMENT_DETAILS_V1)) { + for (claim in listOf(PubkyAuthClaim.USDT_ADDRESS_V1, PubkyAuthClaim.BITCOIN_AND_USDT)) { clearInvocations(watchOnlyAccountRepo) val url = "pubkyauth://signin_grant?x-bitkit-claim=${claim.wireValue}" whenever( @@ -938,7 +938,7 @@ class PubkyAuthApprovalViewModelTest : BaseUnitTest() { } @Test - fun `unavailable receiving address blocks approval and can be retried`() = test { + fun `unavailable optional address can be skipped or retried`() = test { val url = "pubkyauth://signin_grant?x-bitkit-claim=usdt-address-v1" whenever( pubkyRepo.parseAuthUrl(url) @@ -952,11 +952,11 @@ class PubkyAuthApprovalViewModelTest : BaseUnitTest() { sut.load(url) advanceUntilIdle() sut.approveWatchOnlyConsent(url) - assertFalse(sut.uiState.value.canAuthorize) + assertTrue(sut.uiState.value.canAuthorize) + assertFalse(sut.uiState.value.shareUsdt) assertTrue(sut.uiState.value.usdtUnavailable) - sut.requestAuthorize(url) - advanceUntilIdle() - assertEquals(ApprovalState.Authorize, sut.uiState.value.state) + sut.setShareUsdt(true) + assertFalse(sut.uiState.value.canAuthorize) val endpoint = to.bitkit.repositories.Endpoint( methodId = to.bitkit.repositories.MethodId.UsdtArbitrum, value = "reviewed-address", diff --git a/changelog.d/next/1432.added.md b/changelog.d/next/1432.added.md index eb1ecfe462..9c01713d00 100644 --- a/changelog.d/next/1432.added.md +++ b/changelog.d/next/1432.added.md @@ -1 +1 @@ -Send and receive USDT with fees paid in USDT, Paykit contact payments and requests, subscriptions, cross-network deposits, Earn address sharing, and encrypted payment recovery backups. +Send and receive USDT with fees paid in USDT, Paykit contact payments and requests, subscriptions, cross-network deposits, optional Earn address sharing, and encrypted payment recovery backups. diff --git a/docs/earn-receiving-details.md b/docs/earn-receiving-details.md index 9e60309835..d404417e33 100644 --- a/docs/earn-receiving-details.md +++ b/docs/earn-receiving-details.md @@ -1,39 +1,29 @@ # Earn receiving-details claims -Bitkit lets an Earn service request a Bitcoin watch-only account, the existing USDT address on Arbitrum One, or both through the existing Pubky Auth approval flow. This contract covers address sharing, not USDT invoicing, payment verification or purchase delivery. +Earn services request receiving details through Pubky Auth. USDT sharing is optional and uses the existing Arbitrum One account; it creates no account, enables no public-sharing setting, and grants no spending authority. Services see that address's public balance and history. -## Request and approval +Use exactly one `x-bitkit-claim` parameter containing a dot-separated list of independent permissions: -Use exactly one `x-bitkit-claim` query parameter: - -| Claim | Shared details | +| Permission | Shared authority/details | | --- | --- | -| `watch-only-account-v1` | A separate native-SegWit Bitcoin account, using the existing 84-byte payload | -| `usdt-address-v1` | The existing USDT Arbitrum receiving endpoint | -| `payment-details-v1` | Both that endpoint and a separate Bitcoin account | - -All three require exactly `/pub/paykit/:rw`. Unknown or repeated claim parameters and mismatched capabilities are rejected. Changing the claim changes the request identity and companion channel. - -The user first sees the existing Earn introduction, then the authorization review showing the requested assets. The USDT address is expandable and copyable. Approval is unavailable until the address can be read, and Bitkit re-reads it before sending to ensure it is the address reviewed. Canceling before authorization shares nothing and allocates no Bitcoin account. - -USDT sharing creates no account, changes no public-sharing preference and gives no permission to spend. The receiver can observe the account's public balance and transaction history. Different services receive the same USDT address. Bitcoin sharing retains its separate account allocation and tracked retry/recovery lifecycle. - -## Payload - -For `usdt-address-v1`, the unsigned payload is a UTF-8 JSON object with exactly the `usdt-arbitrum-address` key. Its endpoint contains string fields `value` (the EVM address), `chain_id` (`42161`) and `token` (`0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9`). +| `watch-only-account-v1` | Separate native-SegWit Bitcoin account | +| `paykit-access-v1` | Generation-bound Paykit identity secret, never a wallet spending key | +| `usdt-address-v1` | Existing USDT0 Arbitrum One address, if approved | -For `payment-details-v1`, the unsigned JSON additionally contains `bitcoin_account`, with `account_index` (an unsigned integer), `address_type` (`nativeSegwit`) and `xpub` (Base58Check text). Wallet-local names and identifiers are not shared. The xpub's version identifies its Bitcoin network; the server must check it against its configured network. +For example, `paykit-access-v1.watch-only-account-v1.usdt-address-v1` requests all three. Preserve the exact received order for signature and channel derivation. Unknown, duplicate or empty items are rejected. Requests require `/pub/paykit/:rw`. -JSON key order is not significant. Verify the signature over the received bytes before decoding; do not reconstruct or reserialize the object for verification. The existing `watch-only-account-v1` binary format is unchanged. +The existing Earn introduction leads to authorization review. USDT has an optional sharing toggle and expandable/copyable address. If loading fails, the user may retry or authorize without USDT. When selected, Bitkit re-reads the address and checks it matches the reviewed address. Canceling before authorization shares nothing. Bitcoin retains its separate account allocation and retry/recovery lifecycle. -## Signed delivery +## Payload and authentication -Use Paykit's companion-claim approval API with the exact selected claim name. The signature input is UTF-8 `x-bitkit-claim||`, followed by SHA256 of the decoded 32-byte auth request secret, followed by the unsigned payload bytes. Paykit appends the 64-byte Ed25519 signature and encrypts the signed payload using the existing XSalsa20-Poly1305 envelope. +Selections containing USDT use a UTF-8 JSON object. Include only requested and approved fields: -The companion channel is base64url-no-pad of BLAKE3 over UTF-8 `|` followed by the decoded request secret. The normal AuthToken channel is unchanged. Claim delivery precedes normal auth approval. The signature is verified against the creator's authenticated Pubky public key. It binds the receiving details to that identity and request, not to ownership of an EVM private key. +- `usdt-arbitrum-address`: `{value, chain_id: "42161", token: "0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9"}`. Omit this field when declined. +- `bitcoin_account`: `{account_index, address_type: "nativeSegwit", xpub}` when Bitcoin is requested. No wallet-local names or IDs. +- `paykit_access`: `{key_generation, secret}` when Paykit access is requested. The generation is an exact nonzero unsigned 64-bit integer; the 32-byte secret uses unpadded base64url. -## Server integration +Selections without USDT retain the existing binary layouts: Bitcoin 84 bytes, Paykit 41 bytes, both 124 bytes. Those are independent supported permissions, not USDT compatibility paths. -Paykit Server's current implementation accepts only `watch-only-account-v1`. Supporting the new claim names requires using the requested claim name for channel derivation and signature verification, parsing the appropriate payload after verification, validating the pinned endpoint and optional Bitcoin account, and durably storing the selected receiving details before acknowledging setup. Existing Bitcoin setup and stored credentials must remain readable; neither USDT-only sharing nor combined sharing authorizes deleting them. +Paykit signs UTF-8 `x-bitkit-claim||`, SHA256 of the 32-byte AUTH secret, and the unsigned payload. It appends the 64-byte Ed25519 signature and uses its XSalsa20-Poly1305 companion transport. The relay channel is unpadded base64url of BLAKE3 over UTF-8 `|` followed by the AUTH secret. Verify the received bytes before parsing; never reserialize JSON for signature verification. -The server must not treat a shared USDT address as an enabled USDT checkout method. USDT invoice creation and payment verification are separate work. A server should issue these new claim requests only when it can accept and store them. Bitkit should not advertise a completed production Earn integration until that server behavior is available and tested together. +The Creator's authenticated Pubky key verifies the claim. This binds receiving details to the identity and request, not ownership of the EVM private key. The server validates the pinned chain/token, address and Bitcoin account before persistence, and verifies delegated Paykit authority against the identity-signed Noise key authorization. A matching server can request USDT only when configured to store and verify it. Declining USDT leaves Bitcoin setup usable. Reconnect may add a missing USDT address while preserving existing receiving bindings. diff --git a/journeys/pubky-auth/share-receiving-details.xml b/journeys/pubky-auth/share-receiving-details.xml index 8d3d067178..020d32437b 100644 --- a/journeys/pubky-auth/share-receiving-details.xml +++ b/journeys/pubky-auth/share-receiving-details.xml @@ -6,8 +6,11 @@ Verify only USDT Arbitrum details, the existing address and balance/history disclosure are shown Expand the address and copy it; verify it matches the wallet receive address Cancel and verify no Bitcoin account was created - Repeat with x-bitkit-claim=payment-details-v1; verify Bitcoin and USDT appear together, then cancel + Repeat with x-bitkit-claim=watch-only-account-v1.usdt-address-v1; verify Bitcoin and USDT appear together, then cancel Repeat with x-bitkit-claim=watch-only-account-v1; verify only Bitcoin is requested, then cancel - With USDT unavailable, verify USDT authorization is disabled and Retry reloads the address + With USDT unavailable, verify sharing is off and authorization remains enabled; turn USDT sharing on and verify authorization is disabled until Retry loads the address + Open the setup fixture with x-bitkit-claim=paykit-access-v1.watch-only-account-v1.usdt-address-v1 + Continue to authorization; verify the Bitcoin account, Paykit access, and optional USDT sharing toggle are shown + Turn off PubkyAuthShareUsdt; verify authorization remains enabled, then cancel From 7d9c8da55a6bfe6f07c19f4d42486fd1c9839beb Mon Sep 17 00:00:00 2001 From: benk10 Date: Wed, 7 Oct 2026 16:59:42 -0500 Subject: [PATCH 06/62] feat: apply usdt wallet designs --- .../models/NewTransactionSheetDetails.kt | 1 + app/src/main/java/to/bitkit/ui/ContentView.kt | 17 +- .../ui/components/NumberPadTextField.kt | 3 + .../bitkit/ui/components/PaykitAmountView.kt | 8 +- .../java/to/bitkit/ui/components/SendCell.kt | 4 +- .../java/to/bitkit/ui/components/SheetHost.kt | 2 + .../bitkit/ui/components/UsdtAmountHeader.kt | 38 ++- .../CreatePaymentRequestScreen.kt | 7 +- .../IncomingPaymentRequestDetailsScreen.kt | 8 +- .../screens/profile/PubkyAuthApprovalSheet.kt | 6 +- .../subscriptions/CreateSubscriptionScreen.kt | 4 +- .../subscriptions/SubscriptionsScreen.kt | 3 +- .../bitkit/ui/screens/wallets/HomeScreen.kt | 28 +- .../wallets/activity/AllActivityScreen.kt | 32 ++ .../components/ActivityListGrouped.kt | 147 +++++---- .../activity/components/ActivityListSimple.kt | 49 ++- .../wallets/receive/EditInvoiceScreen.kt | 2 +- .../wallets/receive/ReceiveInvoiceUtils.kt | 2 + .../wallets/receive/ReceiveQrScreen.kt | 34 +- .../screens/wallets/receive/ReceiveSheet.kt | 5 +- .../ui/screens/wallets/receive/ReceiveTab.kt | 3 + .../screens/wallets/send/SendAmountScreen.kt | 4 +- .../wallets/usdt/UsdtActivityDetail.kt | 5 +- .../wallets/usdt/UsdtDepositReceiveScreen.kt | 295 +++++++++++------- .../wallets/usdt/UsdtReceiveAmountContent.kt | 232 ++++++++++++++ .../wallets/usdt/UsdtReceiveContent.kt | 104 +++--- .../screens/wallets/usdt/UsdtSendContent.kt | 46 +-- .../screens/wallets/usdt/UsdtWalletScreen.kt | 183 ++++++----- .../bitkit/ui/sheets/NewTransactionSheet.kt | 78 +++-- .../main/java/to/bitkit/ui/theme/Colors.kt | 2 + .../java/to/bitkit/viewmodels/AppViewModel.kt | 12 + app/src/main/res/drawable-nodpi/tether.png | Bin 0 -> 2762 bytes .../main/res/drawable-nodpi/tether_circle.png | Bin 0 -> 2497 bytes .../main/res/drawable-nodpi/tether_coin.png | Bin 0 -> 2257140 bytes .../main/res/drawable-nodpi/usdt_network.png | Bin 0 -> 872 bytes app/src/main/res/values/strings.xml | 13 +- .../bitkit/ui/components/UsdtDisplayTest.kt | 27 ++ docs/screens-map.md | 6 + docs/usdt-qa.md | 13 +- journeys/paykit-quoted-usdt.xml | 4 +- journeys/usdt-bridge-support.xml | 2 +- journeys/usdt-receive-amount-and-units.xml | 13 + journeys/usdt-wallet-navigation.xml | 4 +- 43 files changed, 1037 insertions(+), 409 deletions(-) create mode 100644 app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtReceiveAmountContent.kt create mode 100644 app/src/main/res/drawable-nodpi/tether.png create mode 100644 app/src/main/res/drawable-nodpi/tether_circle.png create mode 100644 app/src/main/res/drawable-nodpi/tether_coin.png create mode 100644 app/src/main/res/drawable-nodpi/usdt_network.png create mode 100644 app/src/test/java/to/bitkit/ui/components/UsdtDisplayTest.kt create mode 100644 journeys/usdt-receive-amount-and-units.xml diff --git a/app/src/main/java/to/bitkit/models/NewTransactionSheetDetails.kt b/app/src/main/java/to/bitkit/models/NewTransactionSheetDetails.kt index 0126dd094d..3963b4b524 100644 --- a/app/src/main/java/to/bitkit/models/NewTransactionSheetDetails.kt +++ b/app/src/main/java/to/bitkit/models/NewTransactionSheetDetails.kt @@ -13,6 +13,7 @@ data class NewTransactionSheetDetails( val activityWalletId: String? = null, val sats: Long = 0, val usdtAmount: ULong? = null, + val usdtTransferId: String? = null, val isLoadingDetails: Boolean = false, ) { companion object { diff --git a/app/src/main/java/to/bitkit/ui/ContentView.kt b/app/src/main/java/to/bitkit/ui/ContentView.kt index 3647abc3d8..c6a007812e 100644 --- a/app/src/main/java/to/bitkit/ui/ContentView.kt +++ b/app/src/main/java/to/bitkit/ui/ContentView.kt @@ -487,8 +487,11 @@ fun ContentView( val isCreatingPaymentRequest by appViewModel.isCreatingPaymentRequest.collectAsStateWithLifecycle() val hwSendViewModel = hiltViewModel() val hwSendUiState by hwSendViewModel.uiState.collectAsStateWithLifecycle() - val canDismissSheet = currentSheet !is Sheet.Send || - (hwSendUiState.canLeave && !appViewModel.isPaykitUsdtBusy) + var receiveBlocking by remember(currentSheet) { mutableStateOf(false) } + val canDismissSheet = !receiveBlocking && ( + currentSheet !is Sheet.Send || + (hwSendUiState.canLeave && !appViewModel.isPaykitUsdtBusy) + ) val isAcceptingSubscription by appViewModel.isAcceptingSubscription.collectAsStateWithLifecycle() val isRetryingInitialSubscriptionPayment by appViewModel.isRetryingInitialSubscriptionPayment.collectAsStateWithLifecycle() @@ -554,6 +557,8 @@ fun ContentView( ReceiveSheet( appViewModel = appViewModel, startRoute = sheet.route, + initialTab = sheet.initialTab, + onBlockingChange = { receiveBlocking = it }, hardwareWalletId = sheet.hardwareWalletId, walletState = walletState, isOffline = connectivityState != ConnectivityState.CONNECTED, @@ -1215,6 +1220,11 @@ private fun NavGraphBuilder.home( ) } } + composableWithDefaultTransitions { entry -> + UsdtWalletScreen(onBack = { + navController.popBackStack() + }, initialTransferId = entry.toRoute().transferId) + } deepLinkableComposable { UsdtWalletScreen(onBack = { navController.popBackStack() }) } @@ -2236,6 +2246,9 @@ sealed interface Routes { @Serializable data object UsdtWallet : Routes.DeepLinkable + @Serializable + data class UsdtActivity(val transferId: String) : Routes.InternalOnly + @Serializable data object Settings : Routes.DeepLinkable diff --git a/app/src/main/java/to/bitkit/ui/components/NumberPadTextField.kt b/app/src/main/java/to/bitkit/ui/components/NumberPadTextField.kt index 4be1c44c8c..fba4c3e8d1 100644 --- a/app/src/main/java/to/bitkit/ui/components/NumberPadTextField.kt +++ b/app/src/main/java/to/bitkit/ui/components/NumberPadTextField.kt @@ -16,6 +16,7 @@ import androidx.compose.ui.semantics.contentDescription import androidx.compose.ui.semantics.semantics import androidx.compose.ui.text.SpanStyle import androidx.compose.ui.text.buildAnnotatedString +import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.text.withStyle import androidx.compose.ui.tooling.preview.Preview import androidx.compose.ui.unit.dp @@ -226,6 +227,7 @@ fun NumberPadAmountText( Display( text = symbol, color = Colors.White64, + fontWeight = FontWeight.ExtraBold, modifier = Modifier.padding(end = 6.dp) ) } @@ -248,6 +250,7 @@ fun NumberPadAmountText( Display( text = symbol, color = Colors.White64, + fontWeight = FontWeight.ExtraBold, modifier = Modifier.padding(start = 6.dp) ) } diff --git a/app/src/main/java/to/bitkit/ui/components/PaykitAmountView.kt b/app/src/main/java/to/bitkit/ui/components/PaykitAmountView.kt index b3605b4d2e..272c5b16f9 100644 --- a/app/src/main/java/to/bitkit/ui/components/PaykitAmountView.kt +++ b/app/src/main/java/to/bitkit/ui/components/PaykitAmountView.kt @@ -3,20 +3,22 @@ package to.bitkit.ui.components import androidx.compose.foundation.layout.Column import androidx.compose.runtime.Composable import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier import to.bitkit.models.PaykitAmount import to.bitkit.models.PaykitAsset import to.bitkit.ui.theme.Colors @Composable -fun PaykitAmountDisplay(amount: PaykitAmount, prefix: String = "") { +fun PaykitAmountDisplay(amount: PaykitAmount, modifier: Modifier = Modifier, prefix: String = "") { if (amount.asset == PaykitAsset.BTC) { MoneyDisplay( sats = amount.atomic.coerceAtMost(Long.MAX_VALUE.toULong()).toLong(), showSymbol = true, prefix = prefix, + modifier = modifier ) } else { - NumberPadAmountText(value = prefix + amount.value, symbol = if (amount.asset == PaykitAsset.USD) "$" else "₮") + NumberPadAmountText(value = prefix + amount.value, symbol = "$", modifier = modifier) } } @@ -36,7 +38,7 @@ fun PaykitAmountCell( ) } else { Column(horizontalAlignment = Alignment.End) { - BodyMSB(text = prefix + (if (amount.asset == PaykitAsset.USD) "$" else "₮") + amount.value) + BodyMSB(text = prefix + "$" + amount.value) status?.let { BodyS(text = it, color = Colors.White64) } } } diff --git a/app/src/main/java/to/bitkit/ui/components/SendCell.kt b/app/src/main/java/to/bitkit/ui/components/SendCell.kt index 5a856fc286..af42572339 100644 --- a/app/src/main/java/to/bitkit/ui/components/SendCell.kt +++ b/app/src/main/java/to/bitkit/ui/components/SendCell.kt @@ -7,6 +7,7 @@ import androidx.compose.material3.Text import androidx.compose.runtime.Composable import androidx.compose.ui.Modifier import androidx.compose.ui.tooling.preview.Preview +import androidx.compose.ui.unit.Dp import androidx.compose.ui.unit.dp import to.bitkit.ui.theme.AppThemeSurface import to.bitkit.ui.theme.Colors @@ -15,13 +16,14 @@ import to.bitkit.ui.theme.Colors fun SendCell( caption: String, modifier: Modifier = Modifier, + dividerSpacing: Dp = 16.dp, content: @Composable () -> Unit, ) { Column(modifier = modifier.fillMaxWidth()) { Caption13Up(text = caption, color = Colors.White64) VerticalSpacer(8.dp) content() - VerticalSpacer(16.dp) + VerticalSpacer(dividerSpacing) HorizontalDivider(modifier = Modifier.fillMaxWidth()) } } diff --git a/app/src/main/java/to/bitkit/ui/components/SheetHost.kt b/app/src/main/java/to/bitkit/ui/components/SheetHost.kt index ced2e3015a..17d395f0ca 100644 --- a/app/src/main/java/to/bitkit/ui/components/SheetHost.kt +++ b/app/src/main/java/to/bitkit/ui/components/SheetHost.kt @@ -36,6 +36,7 @@ import to.bitkit.models.SamRockSetupRequest import to.bitkit.repositories.PaykitPaymentRequest import to.bitkit.repositories.PaykitSubscriptionId import to.bitkit.ui.screens.wallets.receive.ReceiveRoute +import to.bitkit.ui.screens.wallets.receive.ReceiveTab import to.bitkit.ui.shared.modifiers.clickableAlpha import to.bitkit.ui.sheets.BackupRoute import to.bitkit.ui.sheets.PinRoute @@ -71,6 +72,7 @@ sealed interface Sheet { ) : Sheet data class Receive( val route: ReceiveRoute = ReceiveRoute.QR, + val initialTab: ReceiveTab? = null, val hardwareWalletId: String? = null, val presentationId: String = UUID.randomUUID().toString(), ) : Sheet diff --git a/app/src/main/java/to/bitkit/ui/components/UsdtAmountHeader.kt b/app/src/main/java/to/bitkit/ui/components/UsdtAmountHeader.kt index e28de5a7be..ceb8cae5ac 100644 --- a/app/src/main/java/to/bitkit/ui/components/UsdtAmountHeader.kt +++ b/app/src/main/java/to/bitkit/ui/components/UsdtAmountHeader.kt @@ -2,7 +2,17 @@ package to.bitkit.ui.components import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.runtime.Composable +import androidx.compose.runtime.remember import androidx.compose.ui.Modifier +import to.bitkit.ext.nowMillis +import to.bitkit.models.BITCOIN_SYMBOL +import to.bitkit.models.PaykitAsset +import to.bitkit.models.PaykitExchangeRate +import to.bitkit.models.formatMoney +import to.bitkit.repositories.paykitRate +import to.bitkit.ui.LocalCurrencies +import java.math.BigDecimal +import java.math.RoundingMode @Composable internal fun UsdtAmountHeader( @@ -14,11 +24,15 @@ internal fun UsdtAmountHeader( onToggleHide: (() -> Unit)? = null, onClick: () -> Unit = {}, ) { + val rate = LocalCurrencies.current.paykitRate + val sats = remember(amount, rate) { usdtDisplaySats(amount, rate) } + val btc = sats?.formatMoney(LocalCurrencies.current.displayUnit) BalanceHeader( isBitcoinPrimary = false, - smallRowText = "USDT · $network", + smallRowText = btc ?: "USDT · $network", + smallRowSymbol = if (btc != null) BITCOIN_SYMBOL else null, largeRowText = amount, - largeRowSymbol = "₮", + largeRowSymbol = "$", largeRowPrefix = prefix, showSymbol = true, hideBalance = hideBalance, @@ -28,3 +42,23 @@ internal fun UsdtAmountHeader( modifier = modifier.fillMaxWidth() ) } + +private const val USDT_CENT = 10_000uL + +internal fun usdtOverviewAmount(amount: ULong): String { + if (amount > 0uL && amount < USDT_CENT) return "<0.01" + return BigDecimal(amount.toString()).movePointLeft(PaykitAsset.USDT.decimals).setScale(2, RoundingMode.HALF_UP) + .stripTrailingZeros().toPlainString() +} + +internal fun usdtDisplaySats(amount: String, rate: PaykitExchangeRate?, now: Long = nowMillis()): Long? { + val dollars = amount.toBigDecimalOrNull()?.takeIf { it.signum() >= 0 } ?: return null + val price = runCatching { rate?.value(now) }.getOrNull() ?: return null + return runCatching { + dollars.divide( + price, + PaykitAsset.BTC.decimals, + RoundingMode.DOWN + ).movePointRight(PaykitAsset.BTC.decimals).longValueExact() + }.getOrNull() +} diff --git a/app/src/main/java/to/bitkit/ui/screens/paymentrequests/CreatePaymentRequestScreen.kt b/app/src/main/java/to/bitkit/ui/screens/paymentrequests/CreatePaymentRequestScreen.kt index 392547cf52..41f4600da9 100644 --- a/app/src/main/java/to/bitkit/ui/screens/paymentrequests/CreatePaymentRequestScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/paymentrequests/CreatePaymentRequestScreen.kt @@ -279,7 +279,7 @@ private fun PaymentRequestAssetSelector( NumberPadActionButton( text = option.code.uppercase(), outlined = asset != option, - color = if (option == PaykitAsset.BTC) Colors.Brand else Colors.Green, + color = if (option == PaykitAsset.BTC) Colors.Brand else Colors.Usdt, modifier = Modifier.testTag("PaymentRequestAsset${option.name}"), onClick = { if (option != asset) { @@ -363,8 +363,7 @@ internal fun PaymentRequestDetailsContent( horizontalArrangement = Arrangement.spacedBy(8.dp), modifier = Modifier.fillMaxWidth(), ) { - PaykitAmountDisplay(initialDraft.amount) - FillWidth() + PaykitAmountDisplay(initialDraft.amount, modifier = Modifier.weight(1f)) IconButton( onClick = { onEditAmount(updatedDraft()) }, modifier = Modifier @@ -404,7 +403,7 @@ internal fun PaymentRequestDetailsContent( val endpoints = methods.map { it.rawValue } val selected = endpoints.all { it in selectedMethods } val (label, color, id) = when (methods.first()) { - MethodId.UsdtArbitrum -> Triple("USDT", Colors.Green, "usdt") + MethodId.UsdtArbitrum -> Triple("USDT", Colors.Usdt, "usdt") MethodId.Bolt11, MethodId.Lnurl -> Triple( stringResource(R.string.lightning__spending), Colors.Purple, diff --git a/app/src/main/java/to/bitkit/ui/screens/paymentrequests/IncomingPaymentRequestDetailsScreen.kt b/app/src/main/java/to/bitkit/ui/screens/paymentrequests/IncomingPaymentRequestDetailsScreen.kt index bdcf470695..2ede16845d 100644 --- a/app/src/main/java/to/bitkit/ui/screens/paymentrequests/IncomingPaymentRequestDetailsScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/paymentrequests/IncomingPaymentRequestDetailsScreen.kt @@ -51,7 +51,6 @@ import to.bitkit.ui.components.BodyMSB import to.bitkit.ui.components.BodySSB import to.bitkit.ui.components.Caption13Up import to.bitkit.ui.components.FillHeight -import to.bitkit.ui.components.FillWidth import to.bitkit.ui.components.PaykitAmountDisplay import to.bitkit.ui.components.PrimaryButton import to.bitkit.ui.components.PubkyContactAvatar @@ -145,8 +144,11 @@ internal fun IncomingPaymentRequestDetailsContent( ) { VerticalSpacer(16.dp) Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) { - PaykitAmountDisplay(request.amount, prefix = request.detailsAmountPrefix()) - FillWidth() + PaykitAmountDisplay( + request.amount, + prefix = request.detailsAmountPrefix(), + modifier = Modifier.weight(1f) + ) if (request.hasPaymentEvidence) { PaymentRequestDetailsIcon(request) } else { diff --git a/app/src/main/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalSheet.kt b/app/src/main/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalSheet.kt index e9dc592d14..ffc21c3f35 100644 --- a/app/src/main/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalSheet.kt +++ b/app/src/main/java/to/bitkit/ui/screens/profile/PubkyAuthApprovalSheet.kt @@ -327,7 +327,7 @@ private fun ColumnScope.WatchOnlyConsentContent( else -> R.string.profile__auth_approval_watch_only_intro_title } ).withAccent( - accentColor = if (claim?.sharesUsdt == true && !claim.sharesBitcoin) Colors.Green else Colors.Blue + accentColor = if (claim?.sharesUsdt == true && !claim.sharesBitcoin) Colors.Usdt else Colors.Blue ), ) VerticalSpacer(8.dp) @@ -592,7 +592,7 @@ private fun PaymentDetailsSection( VerticalSpacer(8.dp) BodySSB( text = stringResource(R.string.common__copy), - color = Colors.Green, + color = Colors.Usdt, modifier = Modifier .clickable(onClick = copyToClipboard(address)) .testTag("PubkyAuthCopyUsdtAddress") @@ -612,7 +612,7 @@ private fun PaymentDetailsSection( VerticalSpacer(8.dp) BodySSB( text = stringResource(R.string.common__retry), - color = Colors.Green, + color = Colors.Usdt, modifier = Modifier.clickable(onClick = onRetryUsdt) ) } diff --git a/app/src/main/java/to/bitkit/ui/screens/subscriptions/CreateSubscriptionScreen.kt b/app/src/main/java/to/bitkit/ui/screens/subscriptions/CreateSubscriptionScreen.kt index b13bc959f3..0f5ae340dc 100644 --- a/app/src/main/java/to/bitkit/ui/screens/subscriptions/CreateSubscriptionScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/subscriptions/CreateSubscriptionScreen.kt @@ -269,7 +269,7 @@ internal fun CreateSubscriptionDetails( horizontalArrangement = Arrangement.spacedBy(8.dp), modifier = Modifier.fillMaxWidth().clickableAlpha(onClick = onAmountClick) ) { - PaykitAmountDisplay(amount) + PaykitAmountDisplay(amount, modifier = Modifier.weight(1f)) Icon( painter = painterResource(R.drawable.ic_pencil_simple), contentDescription = stringResource(R.string.common__edit), @@ -286,7 +286,7 @@ internal fun CreateSubscriptionDetails( VerticalSpacer(8.dp) Row(horizontalArrangement = Arrangement.spacedBy(16.dp)) { if (MethodId.UsdtArbitrum.rawValue in acceptedMethods) { - BodyMSB(text = "USDT", color = Colors.Green) + BodyMSB(text = "USDT", color = Colors.Usdt) } if (acceptedMethods.any { MethodId.fromRawValue(it)?.isOnchain == true }) { BodyMSB(text = stringResource(R.string.lightning__savings), color = Colors.Brand) diff --git a/app/src/main/java/to/bitkit/ui/screens/subscriptions/SubscriptionsScreen.kt b/app/src/main/java/to/bitkit/ui/screens/subscriptions/SubscriptionsScreen.kt index 3d02e4cccf..c4aa1ed8a2 100644 --- a/app/src/main/java/to/bitkit/ui/screens/subscriptions/SubscriptionsScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/subscriptions/SubscriptionsScreen.kt @@ -479,8 +479,7 @@ fun SubscriptionDetailScreen( Column(verticalArrangement = Arrangement.spacedBy(16.dp), modifier = Modifier.fillMaxWidth()) { Caption13Up(text = subscription.cadenceText(), color = Colors.White64) Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) { - PaykitAmountDisplay(subscription.amount) - FillWidth() + PaykitAmountDisplay(subscription.amount, modifier = Modifier.weight(1f)) SubscriptionAvatar( subscription = subscription, contact = contacts.contactFor(subscription), diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/HomeScreen.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/HomeScreen.kt index 16874911a4..1dacaa4f4b 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/HomeScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/HomeScreen.kt @@ -98,6 +98,7 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.navigation.NavController import androidx.navigation.NavHostController import com.synonym.bitkitcore.Activity +import com.synonym.bitkitcore.usdtFormatAmount import dev.chrisbanes.haze.HazeState import dev.chrisbanes.haze.hazeEffect import dev.chrisbanes.haze.hazeSource @@ -131,8 +132,12 @@ import to.bitkit.models.effectiveSize import to.bitkit.models.toBalance import to.bitkit.models.widget.ArticleModel import to.bitkit.models.widget.BlockModel +import to.bitkit.repositories.UsdtWalletState +import to.bitkit.repositories.paykitRate import to.bitkit.ui.LocalBalances +import to.bitkit.ui.LocalCurrencies import to.bitkit.ui.Routes +import to.bitkit.ui.appViewModel import to.bitkit.ui.components.ActivityBanner import to.bitkit.ui.components.AppStatus import to.bitkit.ui.components.BalanceHeaderView @@ -155,6 +160,7 @@ import to.bitkit.ui.components.Title import to.bitkit.ui.components.TopBarSpacer import to.bitkit.ui.components.VerticalSpacer import to.bitkit.ui.components.WalletBalanceView +import to.bitkit.ui.components.usdtDisplaySats import to.bitkit.ui.navToActivityDetail import to.bitkit.ui.navigateTo import to.bitkit.ui.navigateToAllActivity @@ -200,6 +206,7 @@ import to.bitkit.viewmodels.ActivityListViewModel import to.bitkit.viewmodels.AppViewModel import to.bitkit.viewmodels.SettingsViewModel import to.bitkit.viewmodels.WalletViewModel +import java.math.BigInteger private const val SMALL_SCREEN_HEIGHT_DP = 800 private const val SMALL_SCREEN_SLOT_CAPACITY = 3 @@ -619,9 +626,20 @@ private fun WalletPage( onClickHardwareWallet: (String) -> Unit, onClickUsdt: () -> Unit, ) { + val usdt by appViewModel?.usdtWallet?.collectAsStateWithLifecycle() + ?: remember { mutableStateOf(UsdtWalletState()) } + val slotCapacity = if (isSmallScreen) SMALL_SCREEN_SLOT_CAPACITY else LARGE_SCREEN_SLOT_CAPACITY + val rate = LocalCurrencies.current.paykitRate + val usdtSats = remember( + usdt.balance, + rate + ) { usdt.balance?.let { usdtDisplaySats(usdtFormatAmount(it), rate) } ?: 0L } + val headlineSats = BigInteger( + balances.totalWithHardwareSats.toString() + ).add(BigInteger.valueOf(usdtSats)).min(BigInteger.valueOf(Long.MAX_VALUE)).toLong() val heightStatusBar = WindowInsets.statusBars.asPaddingValues().calculateTopPadding() val pullToRefreshState = rememberPullToRefreshState() - val hasActivity = !latestActivities.isNullOrEmpty() + val hasActivity = !latestActivities.isNullOrEmpty() || usdt.transfers.isNotEmpty() PullToRefreshBox( state = pullToRefreshState, @@ -650,7 +668,7 @@ private fun WalletPage( VerticalSpacer(16.dp) BalanceHeaderView( - sats = balances.totalWithHardwareSats.toLong(), + sats = headlineSats, showEyeIcon = true, testTag = "TotalBalance", modifier = Modifier @@ -696,6 +714,8 @@ private fun WalletPage( ActivityListSimple( items = latestActivities, + maxItems = (slotCapacity - countNonItemSlots(homeUiState)).coerceAtLeast(0), + usdtItems = usdt.transfers, onAllActivityClick = onNavigateToAllActivity, onActivityItemClick = onNavigateToActivityItem, hardwareIds = hardwareIds, @@ -734,6 +754,7 @@ private fun BalancesSection( ) { Column(modifier = Modifier.fillMaxWidth()) { Row( + horizontalArrangement = Arrangement.spacedBy(16.dp), modifier = Modifier .fillMaxWidth() .height(IntrinsicSize.Min) @@ -748,7 +769,6 @@ private fun BalancesSection( .testTag("ActivitySavings") ) VerticalDivider(color = Colors.Gray4) - HorizontalSpacer(16.dp) WalletBalanceView( title = stringResource(R.string.wallet__spending__title), sats = balances.totalLightningSats.toLong(), @@ -777,13 +797,13 @@ private fun HwDevices( wallets.chunked(2).forEach { rowWallets -> VerticalSpacer(16.dp) Row( + horizontalArrangement = Arrangement.spacedBy(16.dp), modifier = Modifier .fillMaxWidth() .height(IntrinsicSize.Min) ) { HwDeviceCell(wallet = rowWallets[0], onClick = onClick) VerticalDivider(color = Colors.Gray4) - HorizontalSpacer(16.dp) val second = rowWallets.getOrNull(1) if (second != null) { HwDeviceCell(wallet = second, onClick = onClick) diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/activity/AllActivityScreen.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/activity/AllActivityScreen.kt index b8828d7318..c57e2258b0 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/activity/AllActivityScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/activity/AllActivityScreen.kt @@ -8,6 +8,7 @@ import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.runtime.Composable import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.getValue +import androidx.compose.runtime.remember import androidx.compose.ui.Modifier import androidx.compose.ui.platform.testTag import androidx.compose.ui.res.stringResource @@ -15,6 +16,7 @@ import androidx.compose.ui.tooling.preview.Preview import androidx.compose.ui.unit.dp import androidx.lifecycle.compose.collectAsStateWithLifecycle import com.synonym.bitkitcore.Activity +import com.synonym.bitkitcore.UsdtTransfer import kotlinx.collections.immutable.ImmutableList import kotlinx.collections.immutable.ImmutableSet import kotlinx.collections.immutable.persistentListOf @@ -35,6 +37,26 @@ import to.bitkit.ui.shared.util.screen import to.bitkit.ui.theme.AppThemeSurface import to.bitkit.viewmodels.ActivityListViewModel +private fun UsdtTransfer.matchesActivityFilter( + tab: ActivityTab, + noTagFilter: Boolean, + search: String, + start: Long?, + end: Long?, +): Boolean { + val tabMatches = when (tab) { + ActivityTab.ALL -> true + ActivityTab.SENT -> !isIncoming + ActivityTab.RECEIVED -> isIncoming + ActivityTab.OTHER -> false + } + val searchMatches = search.isEmpty() || recipient.contains(search, ignoreCase = true) || + txHash?.contains(search, ignoreCase = true) == true || "USDT".contains(search, ignoreCase = true) + return tabMatches && noTagFilter && searchMatches && + (start?.let { timestamp >= (it / 1000).toULong() } != false) && + (end?.let { timestamp <= (it / 1000).toULong() } != false) +} + @OptIn(ExperimentalMaterial3Api::class) @Composable fun AllActivityScreen( @@ -51,11 +73,19 @@ fun AllActivityScreen( val startDate by viewModel.startDate.collectAsStateWithLifecycle() val selectedTab by viewModel.selectedTab.collectAsStateWithLifecycle() + val endDate by viewModel.endDate.collectAsStateWithLifecycle() + val usdt by app.usdtWallet.collectAsStateWithLifecycle() + val usdtItems = remember(usdt.transfers, selectedTab, searchText, selectedTags, startDate, endDate) { + usdt.transfers.filter { + it.matchesActivityFilter(selectedTab, selectedTags.isEmpty(), searchText, startDate, endDate) + }.toImmutableList() + } val tabs = activityTabs val currentTabIndex = tabs.indexOf(selectedTab) AllActivityScreenContent( filteredActivities = filteredActivities, + usdtItems = usdtItems, hardwareIds = hardwareIds, searchText = searchText, onSearchTextChange = { viewModel.setSearchText(it) }, @@ -79,6 +109,7 @@ private fun AllActivityScreenContent( filteredActivities: ImmutableList?, searchText: String, hardwareIds: ImmutableSet = persistentSetOf(), + usdtItems: ImmutableList = persistentListOf(), onSearchTextChange: (String) -> Unit, hasTagFilter: Boolean, selectedTags: ImmutableSet, @@ -130,6 +161,7 @@ private fun AllActivityScreenContent( ) { topPadding -> ActivityListGrouped( items = filteredActivities, + usdtItems = usdtItems, onActivityItemClick = onActivityItemClick, onEmptyActivityRowClick = onEmptyActivityRowClick, hardwareIds = hardwareIds, diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/activity/components/ActivityListGrouped.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/activity/components/ActivityListGrouped.kt index 24945106a8..161b83063a 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/activity/components/ActivityListGrouped.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/activity/components/ActivityListGrouped.kt @@ -23,6 +23,7 @@ import androidx.compose.ui.tooling.preview.Preview import androidx.compose.ui.unit.dp import androidx.lifecycle.compose.collectAsStateWithLifecycle import com.synonym.bitkitcore.Activity +import com.synonym.bitkitcore.UsdtTransfer import kotlinx.collections.immutable.ImmutableList import kotlinx.collections.immutable.ImmutableSet import kotlinx.collections.immutable.persistentListOf @@ -30,11 +31,14 @@ import kotlinx.collections.immutable.persistentSetOf import to.bitkit.R import to.bitkit.ext.scopedId import to.bitkit.ui.activityListViewModel +import to.bitkit.ui.appViewModel import to.bitkit.ui.components.BodyM import to.bitkit.ui.components.Caption13Up import to.bitkit.ui.components.TertiaryButton import to.bitkit.ui.components.VerticalSpacer import to.bitkit.ui.screens.wallets.activity.utils.previewActivityItems +import to.bitkit.ui.screens.wallets.usdt.UsdtActivityRow +import to.bitkit.ui.settingsViewModel import to.bitkit.ui.theme.AppThemeSurface import to.bitkit.ui.theme.Colors import java.time.Instant @@ -58,17 +62,18 @@ fun ActivityListGrouped( showContactAvatar: Boolean = true, hardwareIds: ImmutableSet = persistentSetOf(), titleProvider: @Composable (Activity) -> String? = { null }, + usdtItems: ImmutableList = persistentListOf(), ) { - val contacts by activityListViewModel?.contacts?.collectAsStateWithLifecycle() ?: remember { - mutableStateOf(persistentListOf()) - } + val app = appViewModel + val settings = settingsViewModel + val hideBalance by settings?.hideBalance?.collectAsStateWithLifecycle() ?: remember { mutableStateOf(false) } Column( horizontalAlignment = Alignment.CenterHorizontally, modifier = modifier.fillMaxSize() ) { - if (!items.isNullOrEmpty()) { - val groupedItems = groupActivityItems(items) + if (!items.isNullOrEmpty() || usdtItems.isNotEmpty()) { + val groupedItems = remember(items, usdtItems) { groupActivityItems(items.orEmpty(), usdtItems) } LazyColumn( state = listState, @@ -79,18 +84,15 @@ fun ActivityListGrouped( itemsIndexed( items = groupedItems, key = { index, item -> - when (item) { - is String -> "header_$item" - is Activity -> when (item) { - is Activity.Lightning -> "lightning_${item.scopedId()}" - is Activity.Onchain -> "onchain_${item.scopedId()}" - } - - else -> "item_$index" - } + groupedActivityKey(index, item) } ) { index, item -> when (item) { + is UsdtTransfer -> { + UsdtActivityRow(item, hideBalance, onClick = { app?.navigateToUsdtActivity(item.id) }) + if (index < groupedItems.lastIndex) VerticalSpacer(16.dp) + } + is String -> { Caption13Up( text = item, @@ -115,13 +117,13 @@ fun ActivityListGrouped( placementSpec = tween(durationMillis = 300) ) ) { - ActivityRow( - item = item, - onClick = onActivityItemClick, - testTag = "$activityTestTagPrefix-$index", - title = titleProvider(item) ?: contactActivityTitle(item, contacts), - isHardware = item.scopedId() in hardwareIds, - contact = if (showContactAvatar) contactForActivity(item, contacts) else null, + ActivityContactRow( + item, + onActivityItemClick, + "$activityTestTagPrefix-$index", + titleProvider(item), + hardwareIds, + showContactAvatar ) if (index < groupedItems.lastIndex) { VerticalSpacer(16.dp) @@ -162,6 +164,36 @@ fun ActivityListGrouped( } } +@Composable +private fun ActivityContactRow( + item: Activity, + onClick: (Activity) -> Unit, + testTag: String, + title: String?, + hardwareIds: ImmutableSet, + showContactAvatar: Boolean, +) { + val contacts by activityListViewModel?.contacts?.collectAsStateWithLifecycle() ?: remember { + mutableStateOf(persistentListOf()) + } + ActivityRow( + item = item, + onClick = onClick, + testTag = testTag, + title = title ?: contactActivityTitle(item, contacts), + isHardware = item.scopedId() in hardwareIds, + contact = if (showContactAvatar) contactForActivity(item, contacts) else null + ) +} + +private fun groupedActivityKey(index: Int, item: Any): String = when (item) { + is UsdtTransfer -> "usdt_${item.id}" + is String -> "header_$item" + is Activity.Lightning -> "lightning_${item.scopedId()}" + is Activity.Onchain -> "onchain_${item.scopedId()}" + else -> "item_$index" +} + @Suppress("LongMethod", "LongParameterList") fun LazyListScope.activityListGroupedItems( items: ImmutableList?, @@ -177,15 +209,7 @@ fun LazyListScope.activityListGroupedItems( itemsIndexed( items = groupedItems, key = { index, item -> - when (item) { - is String -> "header_$item" - is Activity -> when (item) { - is Activity.Lightning -> "lightning_${item.scopedId()}" - is Activity.Onchain -> "onchain_${item.scopedId()}" - } - - else -> "item_$index" - } + groupedActivityKey(index, item) }, ) { index, item -> when (item) { @@ -264,7 +288,7 @@ fun LazyListScope.activityListGroupedItems( // region utils @Suppress("CyclomaticComplexMethod") -private fun groupActivityItems(activityItems: List): List { +private fun groupActivityItems(activityItems: List, usdtItems: List = emptyList()): List { val now = Instant.now() val zoneId = ZoneId.systemDefault() val today = now.atZone(zoneId).truncatedTo(ChronoUnit.DAYS) @@ -276,18 +300,24 @@ private fun groupActivityItems(activityItems: List): List { val startOfMonth = today.withDayOfMonth(1).toInstant().epochSecond val startOfYear = today.withDayOfYear(1).toInstant().epochSecond - val todayItems = mutableListOf() - val yesterdayItems = mutableListOf() - val weekItems = mutableListOf() - val monthItems = mutableListOf() - val yearItems = mutableListOf() - val earlierItems = mutableListOf() + val todayItems = mutableListOf() + val yesterdayItems = mutableListOf() + val weekItems = mutableListOf() + val monthItems = mutableListOf() + val yearItems = mutableListOf() + val earlierItems = mutableListOf() - for (item in activityItems) { - val timestamp = when (item) { - is Activity.Lightning -> item.v1.timestamp.toLong() - is Activity.Onchain -> item.v1.timestamp.toLong() + val entries = ( + activityItems.map { + WalletActivity.Bitcoin(it) + } + usdtItems.map { WalletActivity.Usdt(it) } + ).sortedByDescending { it.timestamp } + for (entry in entries) { + val item: Any = when (entry) { + is WalletActivity.Bitcoin -> entry.item + is WalletActivity.Usdt -> entry.item } + val timestamp = entry.timestamp.toLong() when { timestamp >= startOfDay -> todayItems.add(item) timestamp >= startOfYesterday -> yesterdayItems.add(item) @@ -299,29 +329,18 @@ private fun groupActivityItems(activityItems: List): List { } return buildList { - if (todayItems.isNotEmpty()) { - add("TODAY") - addAll(todayItems) - } - if (yesterdayItems.isNotEmpty()) { - add("YESTERDAY") - addAll(yesterdayItems) - } - if (weekItems.isNotEmpty()) { - add("THIS WEEK") - addAll(weekItems) - } - if (monthItems.isNotEmpty()) { - add("THIS MONTH") - addAll(monthItems) - } - if (yearItems.isNotEmpty()) { - add("THIS YEAR") - addAll(yearItems) - } - if (earlierItems.isNotEmpty()) { - add("EARLIER") - addAll(earlierItems) + listOf( + "TODAY" to todayItems, + "YESTERDAY" to yesterdayItems, + "THIS WEEK" to weekItems, + "THIS MONTH" to monthItems, + "THIS YEAR" to yearItems, + "EARLIER" to earlierItems, + ).forEach { (title, items) -> + if (items.isNotEmpty()) { + add(title) + addAll(items) + } } } } diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/activity/components/ActivityListSimple.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/activity/components/ActivityListSimple.kt index d52ce7970a..f5737c79f4 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/activity/components/ActivityListSimple.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/activity/components/ActivityListSimple.kt @@ -15,16 +15,21 @@ import androidx.compose.ui.tooling.preview.Preview import androidx.compose.ui.unit.dp import androidx.lifecycle.compose.collectAsStateWithLifecycle import com.synonym.bitkitcore.Activity +import com.synonym.bitkitcore.UsdtTransfer import kotlinx.collections.immutable.ImmutableList import kotlinx.collections.immutable.ImmutableSet import kotlinx.collections.immutable.persistentListOf import kotlinx.collections.immutable.persistentSetOf import to.bitkit.R import to.bitkit.ext.scopedId +import to.bitkit.ext.timestamp import to.bitkit.ui.activityListViewModel +import to.bitkit.ui.appViewModel import to.bitkit.ui.components.TertiaryButton import to.bitkit.ui.components.VerticalSpacer import to.bitkit.ui.screens.wallets.activity.utils.previewActivityItems +import to.bitkit.ui.screens.wallets.usdt.UsdtActivityRow +import to.bitkit.ui.settingsViewModel import to.bitkit.ui.theme.AppThemeSurface @Composable @@ -33,8 +38,17 @@ fun ActivityListSimple( onAllActivityClick: () -> Unit, onActivityItemClick: (Activity) -> Unit, hardwareIds: ImmutableSet = persistentSetOf(), + usdtItems: ImmutableList = persistentListOf(), + maxItems: Int = 4, ) { - if (items.isNullOrEmpty()) return + if (items.isNullOrEmpty() && usdtItems.isEmpty()) return + val app = appViewModel + val settings = settingsViewModel + val hideBalance by settings?.hideBalance?.collectAsStateWithLifecycle() ?: remember { mutableStateOf(false) } + val rows = remember(items, usdtItems, maxItems) { + (items.orEmpty().map { WalletActivity.Bitcoin(it) } + usdtItems.map { WalletActivity.Usdt(it) }) + .sortedByDescending { it.timestamp }.take(maxItems) + } val contacts by activityListViewModel?.contacts?.collectAsStateWithLifecycle() ?: remember { mutableStateOf(persistentListOf()) @@ -44,18 +58,23 @@ fun ActivityListSimple( horizontalAlignment = Alignment.CenterHorizontally, modifier = Modifier.fillMaxWidth() ) { - items.forEachIndexed { index, item -> - ActivityRow( - item = item, - onClick = onActivityItemClick, - testTag = "ActivityShort-$index", - title = contactActivityTitle(item, contacts), - isHardware = item.scopedId() in hardwareIds, - contact = contactForActivity(item, contacts), - ) - if (index < items.lastIndex) { - VerticalSpacer(16.dp) + rows.forEachIndexed { index, entry -> + when (entry) { + is WalletActivity.Bitcoin -> ActivityRow( + item = entry.item, + onClick = onActivityItemClick, + testTag = "ActivityShort-$index", + title = contactActivityTitle(entry.item, contacts), + isHardware = entry.item.scopedId() in hardwareIds, + contact = contactForActivity(entry.item, contacts), + ) + is WalletActivity.Usdt -> UsdtActivityRow( + entry.item, + hideBalance, + onClick = { app?.navigateToUsdtActivity(entry.item.id) } + ) } + if (index < rows.lastIndex) VerticalSpacer(16.dp) } TertiaryButton( text = stringResource(R.string.wallet__activity_show_all), @@ -90,3 +109,9 @@ private fun PreviewEmpty() { ) } } + +internal sealed interface WalletActivity { + val timestamp: ULong + data class Bitcoin(val item: Activity) : WalletActivity { override val timestamp get() = item.timestamp() } + data class Usdt(val item: UsdtTransfer) : WalletActivity { override val timestamp get() = item.timestamp } +} diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/receive/EditInvoiceScreen.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/receive/EditInvoiceScreen.kt index 7e47911a3a..2f9f67a1c7 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/receive/EditInvoiceScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/receive/EditInvoiceScreen.kt @@ -191,7 +191,7 @@ private fun ReceiveTab.toReceiveLiquiditySource(): ReceiveLiquiditySource { ReceiveTab.SAVINGS -> SAVINGS ReceiveTab.AUTO -> AUTO ReceiveTab.SPENDING -> SPENDING - ReceiveTab.HARDWARE -> SAVINGS + ReceiveTab.HARDWARE, ReceiveTab.USDT -> SAVINGS } } diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveInvoiceUtils.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveInvoiceUtils.kt index e4e5e197ad..78e9ceeae1 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveInvoiceUtils.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveInvoiceUtils.kt @@ -43,6 +43,7 @@ fun getInvoiceForTab( ?: bolt11.takeIf { isNodeRunning && canCreateLightningInvoice }.orEmpty() } + ReceiveTab.USDT -> "" ReceiveTab.HARDWARE -> hardwareAddress.takeIf(String::isNotBlank)?.let { address -> Bip21Utils.buildBip21Url( bitcoinAddress = address, @@ -107,6 +108,7 @@ fun getQrLogoResource(tab: ReceiveTab): Int { ReceiveTab.SAVINGS -> R.drawable.ic_btc_circle ReceiveTab.AUTO -> R.drawable.ic_unified_circle ReceiveTab.SPENDING -> R.drawable.ic_ln_circle + ReceiveTab.USDT -> R.drawable.tether_circle ReceiveTab.HARDWARE -> R.drawable.ic_btc_circle_blue } } diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveQrScreen.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveQrScreen.kt index 8a3c4b0b2c..a4013adc14 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveQrScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveQrScreen.kt @@ -50,6 +50,7 @@ import androidx.compose.ui.text.style.TextOverflow import androidx.compose.ui.tooling.preview.Devices.NEXUS_5 import androidx.compose.ui.tooling.preview.Preview import androidx.compose.ui.unit.dp +import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel import kotlinx.collections.immutable.persistentListOf import kotlinx.collections.immutable.persistentMapOf import kotlinx.collections.immutable.toImmutableList @@ -58,6 +59,7 @@ import kotlinx.coroutines.flow.distinctUntilChanged import kotlinx.coroutines.launch import org.lightningdevkit.ldknode.ChannelDetails import to.bitkit.R +import to.bitkit.env.Env import to.bitkit.ext.calculateRemoteBalance import to.bitkit.ext.setClipboardText import to.bitkit.models.NodeLifecycleState @@ -79,6 +81,7 @@ import to.bitkit.ui.components.Tooltip import to.bitkit.ui.components.VerticalSpacer import to.bitkit.ui.scaffold.SheetTopBar import to.bitkit.ui.screens.wallets.activity.components.CustomTabRowWithSpacing +import to.bitkit.ui.screens.wallets.usdt.UsdtDepositReceiveScreen import to.bitkit.ui.shared.effects.SetMaxBrightness import to.bitkit.ui.shared.modifiers.sheetHeight import to.bitkit.ui.shared.util.gradientBackground @@ -101,6 +104,7 @@ fun ReceiveQrScreen( onClickHardwareEditInvoice: () -> Unit = { onClickEditInvoice(ReceiveTab.HARDWARE) }, modifier: Modifier = Modifier, initialTab: ReceiveTab? = null, + onBlockingChange: (Boolean) -> Unit = {}, hardwareWalletId: String? = null, /** Vendor name shown on the hardware tab, e.g. "Trezor" or "Jade". */ hardwareTabLabel: String? = null, @@ -142,6 +146,7 @@ fun ReceiveQrScreen( add(ReceiveTab.AUTO) } add(ReceiveTab.SPENDING) + if (Env.isUsdtEnabled && cjitInvoice == null) add(ReceiveTab.USDT) }.toImmutableList() } val defaultTab = remember(visibleTabs, initialTab) { @@ -214,7 +219,9 @@ fun ReceiveQrScreen( } LaunchedEffect(canCreateLightningInvoice, cjitInvoice, initialTab) { - if (initialTab == ReceiveTab.HARDWARE) return@LaunchedEffect + if (initialTab == ReceiveTab.HARDWARE || initialTab == ReceiveTab.USDT || selectedTab == ReceiveTab.USDT) { + return@LaunchedEffect + } if (!canCreateLightningInvoice && cjitInvoice.isNullOrEmpty()) { selectedTab = ReceiveTab.SAVINGS lazyListState.scrollToItem(visibleTabs.indexOf(ReceiveTab.SAVINGS).coerceAtLeast(0)) @@ -225,7 +232,7 @@ fun ReceiveQrScreen( snapshotFlow { lazyListState.firstVisibleItemIndex } .distinctUntilChanged() .collect { index -> - if (index < visibleTabs.size && index > -1) { + if (selectedTab != ReceiveTab.USDT && index < visibleTabs.size && index > -1) { val tab = visibleTabs[index] selectedTab = tab } @@ -278,6 +285,28 @@ fun ReceiveQrScreen( cjitInvoice.isNullOrEmpty() } + fun selectReceiveTab(tab: ReceiveTab) { + selectedTab = tab + hasUserSelectedTab = true + scope.launch { lazyListState.scrollToItem(visibleTabs.indexOf(tab)) } + } + + if (selectedTab == ReceiveTab.USDT) { + Column( + modifier = modifier.fillMaxSize().gradientBackground().navigationBarsPadding().padding(horizontal = 16.dp) + ) { + UsdtDepositReceiveScreen( + viewModel = hiltViewModel(), + tabs = visibleTabs, + onSelectTab = ::selectReceiveTab, + onBack = { selectReceiveTab(ReceiveTab.SAVINGS) }, + onBlockingChange = onBlockingChange, + onContacts = onClickPaymentRequestContacts.takeIf { showPaymentRequestContacts }, + ) + } + return + } + Column( modifier = modifier .fillMaxSize() @@ -741,6 +770,7 @@ private fun ReceiveDetailsView( } } + ReceiveTab.USDT -> Unit ReceiveTab.HARDWARE -> { hardwareAddress?.let { address -> CopyAddressCard( diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveSheet.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveSheet.kt index ad3c47e0c1..5a50e0736f 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveSheet.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveSheet.kt @@ -68,6 +68,8 @@ fun ReceiveSheet( walletState: WalletState, isOffline: Boolean, startRoute: ReceiveRoute = ReceiveRoute.QR, + initialTab: ReceiveTab? = null, + onBlockingChange: (Boolean) -> Unit = {}, hardwareWalletId: String? = null, editInvoiceAmountViewModel: AmountInputViewModel = hiltViewModel(), paymentRequestAmountViewModel: AmountInputViewModel = hiltViewModel(key = "PaymentRequestAmount"), @@ -174,7 +176,8 @@ fun ReceiveSheet( resetEditInvoiceAmount() navController.navigateTo(ReceiveRoute.EditInvoice) }, - initialTab = invoiceEditState.initialTab(hardwareWalletId), + initialTab = invoiceEditState.initialTab(hardwareWalletId) ?: initialTab, + onBlockingChange = onBlockingChange, hardwareWalletId = selectedHardwareWalletId, hardwareTabLabel = hardwareWallets.firstOrNull { it.id == selectedHardwareWalletId } ?.let { stringResource(it.vendor.modelNameRes()) }, diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveTab.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveTab.kt index 70186028af..d5ffa4ffa9 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveTab.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveTab.kt @@ -11,6 +11,7 @@ enum class ReceiveTab : TabItem { SAVINGS, AUTO, SPENDING, + USDT, /** The paired hardware wallet; its label carries the vendor name (see [ReceiveQrScreen]). */ HARDWARE; @@ -21,6 +22,7 @@ enum class ReceiveTab : TabItem { SAVINGS -> stringResource(R.string.wallet__receive_tab_savings) AUTO -> stringResource(R.string.wallet__receive_tab_auto) SPENDING -> stringResource(R.string.wallet__receive_tab_spending) + USDT -> "USDT" HARDWARE -> stringResource(R.string.hardware__receive_tab_hardware) } @@ -29,6 +31,7 @@ enum class ReceiveTab : TabItem { SAVINGS -> Colors.Brand AUTO -> Colors.Brand SPENDING -> Colors.Purple + USDT -> Colors.Usdt HARDWARE -> Colors.Blue } } diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendAmountScreen.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendAmountScreen.kt index 9d3667258a..061a732010 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendAmountScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendAmountScreen.kt @@ -270,7 +270,7 @@ private fun SendAmountNodeRunning( if (uiState.paykitUsesUsdt) { NumberPadAmountText( value = uiState.paykitAmount.ifEmpty { "0" }, - symbol = "₮", + symbol = "$", modifier = Modifier.testTag("SendNumberField") ) } else { @@ -427,7 +427,7 @@ private fun PaymentMethodButton( } private fun paymentMethodColor(uiState: SendUiState): Color = when { - uiState.paykitUsesUsdt -> Colors.Green + uiState.paykitUsesUsdt -> Colors.Usdt uiState.hardwareWalletId != null -> Colors.Blue uiState.payMethod == SendMethod.ONCHAIN -> Colors.Brand else -> Colors.Purple diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtActivityDetail.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtActivityDetail.kt index c152f03ad0..2c103560da 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtActivityDetail.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtActivityDetail.kt @@ -36,6 +36,7 @@ import to.bitkit.ui.components.SecondaryButton import to.bitkit.ui.components.SendCell import to.bitkit.ui.components.UsdtAmountHeader import to.bitkit.ui.components.VerticalSpacer +import to.bitkit.ui.components.usdtOverviewAmount import to.bitkit.ui.scaffold.AppTopBar import to.bitkit.ui.scaffold.DrawerNavIcon import to.bitkit.ui.screens.wallets.activity.components.ActivityRowSurface @@ -63,7 +64,7 @@ internal fun UsdtActivityRow(transfer: UsdtTransfer, hideBalance: Boolean, onCli AmountViewContent( title = usdtFormatAmount(transfer.activityAmount), titlePrefix = if (transfer.isIncoming) "+" else "−", - subtitle = "USDT", + subtitle = "$ " + usdtOverviewAmount(transfer.activityAmount), hideBalance = hideBalance ) } @@ -197,7 +198,7 @@ private val UsdtTransfer.iconResource: Int get() = when (status) { private val UsdtTransfer.statusColor get() = when (status) { UsdtTransferStatus.FAILED, UsdtTransferStatus.REPLACED -> Colors.Red UsdtTransferStatus.BRIDGE_NEEDS_ATTENTION, UsdtTransferStatus.BRIDGE_FAILED -> Colors.Yellow - else -> Colors.Green + else -> Colors.Usdt } private val UsdtTransferStatus.labelResource: Int get() = when (this) { diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtDepositReceiveScreen.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtDepositReceiveScreen.kt index d0d7daf50a..307f0f61e4 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtDepositReceiveScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtDepositReceiveScreen.kt @@ -1,19 +1,22 @@ package to.bitkit.ui.screens.wallets.usdt import androidx.activity.compose.BackHandler +import androidx.compose.foundation.Image +import androidx.compose.foundation.background import androidx.compose.foundation.layout.Arrangement -import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.ColumnScope import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.foundation.text.selection.SelectionContainer import androidx.compose.foundation.verticalScroll import androidx.compose.material3.AlertDialog -import androidx.compose.material3.DropdownMenu -import androidx.compose.material3.DropdownMenuItem -import androidx.compose.material3.HorizontalDivider +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButton import androidx.compose.material3.Text import androidx.compose.material3.TextButton import androidx.compose.runtime.Composable @@ -24,8 +27,10 @@ import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember import androidx.compose.runtime.rememberCoroutineScope import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.platform.testTag +import androidx.compose.ui.res.painterResource import androidx.compose.ui.res.stringResource import androidx.compose.ui.unit.dp import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel @@ -35,31 +40,34 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.lifecycle.repeatOnLifecycle import com.synonym.bitkitcore.UsdtDepositDetail import com.synonym.bitkitcore.UsdtDepositNetwork -import com.synonym.bitkitcore.UsdtException import com.synonym.bitkitcore.usdtFormatAmount +import kotlinx.collections.immutable.ImmutableList import kotlinx.coroutines.delay import kotlinx.coroutines.launch import to.bitkit.R import to.bitkit.env.Env +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAsset import to.bitkit.repositories.UsdtWalletState +import to.bitkit.ui.components.BodyM +import to.bitkit.ui.components.BodyMSB import to.bitkit.ui.components.BodyS import to.bitkit.ui.components.BodySSB -import to.bitkit.ui.components.Caption13Up import to.bitkit.ui.components.FillHeight -import to.bitkit.ui.components.NumberPad -import to.bitkit.ui.components.NumberPadActionButton -import to.bitkit.ui.components.NumberPadAmountText -import to.bitkit.ui.components.NumberPadType +import to.bitkit.ui.components.FillWidth import to.bitkit.ui.components.PrimaryButton import to.bitkit.ui.components.SecondaryButton import to.bitkit.ui.components.SendCell +import to.bitkit.ui.components.TertiaryButton import to.bitkit.ui.components.TextInput import to.bitkit.ui.components.UsdtAmountHeader import to.bitkit.ui.components.VerticalSpacer import to.bitkit.ui.scaffold.SheetTopBar import to.bitkit.ui.screens.wallets.activity.components.ActivityRowSurface +import to.bitkit.ui.screens.wallets.activity.components.CustomTabRowWithSpacing +import to.bitkit.ui.screens.wallets.receive.ReceiveTab +import to.bitkit.ui.shared.modifiers.clickableAlpha import to.bitkit.ui.theme.Colors -import to.bitkit.ui.utils.NumberPadInputHandler import java.text.NumberFormat import java.util.Locale import kotlin.time.Duration.Companion.seconds @@ -68,14 +76,18 @@ import kotlin.time.Duration.Companion.seconds @Composable internal fun ColumnScope.UsdtDepositReceiveScreen( viewModel: UsdtViewModel, + tabs: ImmutableList, + onSelectTab: (ReceiveTab) -> Unit, onBack: () -> Unit, onBlockingChange: (Boolean) -> Unit, + onContacts: (() -> Unit)? = null, deposits: UsdtDepositViewModel = hiltViewModel(), ) { val wallet by viewModel.wallet.collectAsStateWithLifecycle() val settings by viewModel.settings.collectAsStateWithLifecycle() val walletUi by viewModel.state.collectAsStateWithLifecycle() val state by deposits.state.collectAsStateWithLifecycle() + var page by remember { mutableStateOf(ReceivePage.ADDRESS) } var amount by remember { mutableStateOf("") } var refundAddress by remember(state.detail?.deposit?.id) { mutableStateOf("") } var approved by remember { mutableStateOf(null) } @@ -87,7 +99,20 @@ internal fun ColumnScope.UsdtDepositReceiveScreen( if (authentication) { authentication = false approved = null - } else if (!deposits.back()) onBack() + } else if (!deposits.back()) { + when (page) { + ReceivePage.FEES -> { + deposits.selectNetwork(state.network) + page = ReceivePage.AMOUNT + } + ReceivePage.AMOUNT -> { + if (state.network != null && state.address == null) deposits.selectNetwork(null) + page = ReceivePage.ADDRESS + } + ReceivePage.NETWORKS -> page = ReceivePage.ADDRESS + ReceivePage.ADDRESS -> onBack() + } + } } val refund = { approved?.let { deposits.refund(it.id, it.offset, it.address, it.network) } @@ -101,6 +126,8 @@ internal fun ColumnScope.UsdtDepositReceiveScreen( DepositPolling(pendingId, lifecycle, { confirmation || authentication || approved != null }) { deposits.detail(it) } + LaunchedEffect(state.address) { if (state.address != null) page = ReceivePage.FEES } + UsdtRefreshEffect(viewModel, receiving = true, onReceived = { !state.busy && !authentication && !confirmation }) BackHandler(onBack = back) if (authentication) { UsdtAuthentication( @@ -117,31 +144,77 @@ internal fun ColumnScope.UsdtDepositReceiveScreen( } else { SheetTopBar( titleText = stringResource( - if (state.history) R.string.usdt__deposit_history else R.string.usdt__receive_title + if (state.history) { + R.string.usdt__deposit_history + } else { + when (page) { + ReceivePage.ADDRESS -> R.string.usdt__receive_title + ReceivePage.NETWORKS -> R.string.usdt__receive_network_title + ReceivePage.AMOUNT -> R.string.usdt__receive_amount_title + ReceivePage.FEES -> R.string.usdt__receive_fees_title + } + } ), - onBack = back, + onBack = back.takeIf { state.history || page != ReceivePage.ADDRESS }, + action = if (page == ReceivePage.ADDRESS && !state.history && onContacts != null) { + { + IconButton(onClick = onContacts) { + Icon( + painterResource(R.drawable.ic_users), + stringResource(R.string.wallet__payment_request_choose_recipient) + ) + } + } + } else { + null + }, ) VerticalSpacer(16.dp) + if (page == ReceivePage.ADDRESS && !state.history) { + CustomTabRowWithSpacing( + tabs = tabs, + currentTabIndex = tabs.indexOf(ReceiveTab.USDT), + onTabChange = onSelectTab + ) + VerticalSpacer(16.dp) + } walletUi.error?.let { BodyS(stringResource(it), color = Colors.Brand) } Content( + page = page, + onPage = { page = it }, wallet = wallet, receiveError = walletUi.refreshError, state = state, amount = amount, refundAddress = refundAddress, hideBalance = settings.hideBalance, - onNetwork = deposits::selectNetwork, + onNetwork = { + if (state.network != it) { + amount = "" + deposits.selectNetwork(it) + } + page = if (it == null || state.address != null && state.network == it) { + ReceivePage.ADDRESS + } else { + ReceivePage.AMOUNT + } + }, onAmount = { if (amount != it) deposits.clearAmountError() amount = it }, onRefundAddress = { refundAddress = it }, - onCreate = { deposits.prepare(amount) }, + onCreate = { + if (state.network == null) page = ReceivePage.ADDRESS else deposits.prepare(amount) + }, onHistory = { deposits.history() }, onMore = { state.nextOffset?.let { deposits.history(it) } }, onDetail = { scope.launch { deposits.detail(it) } }, onRefund = { if (!deposits.state.value.busy) confirmation = true }, - onRefresh = { deposits.selectNetwork(state.network) }, + onRefresh = { + deposits.selectNetwork(state.network) + page = ReceivePage.AMOUNT + }, ) } if (confirmation) { @@ -224,6 +297,8 @@ private fun RefundDialog(network: String, address: String, onCancel: () -> Unit, @Composable private fun ColumnScope.Content( + page: ReceivePage, + onPage: (ReceivePage) -> Unit, wallet: UsdtWalletState, receiveError: Int?, state: DepositUiState, @@ -244,39 +319,50 @@ private fun ColumnScope.Content( DepositHistory(state, refundAddress, hideBalance, onRefundAddress, onRefund, onMore, onDetail, onHistory) return } - NetworkSelector(state, onNetwork, onHistory) - if (state.network == null) { - state.error?.let { BodyS(stringResource(it), color = Colors.White64) } - UsdtReceiveContent(wallet.address, wallet.receiveUri, error = receiveError) - } else if (state.address != null) { - val address = state.address - UsdtReceiveContent( - address.address, - address.uri, - null, - R.string.usdt__deposit_notice - ) { - DepositField(R.string.usdt__deposit_estimate, address.estimatedReceived.usdtText(false)) - DepositField( - R.string.usdt__deposit_cost, + when (page) { + ReceivePage.NETWORKS -> NetworkSelector(state, onNetwork, onHistory) + ReceivePage.AMOUNT -> UsdtReceiveAmountContent( + amount, + state.network == null, + state.busy, + state.error, + state.amountLimits, + onAmount, + onCreate + ) + ReceivePage.FEES -> state.address?.let { address -> + UsdtAmountHeader(usdtFormatAmount(address.amount), state.network?.label ?: "Arbitrum One") + VerticalSpacer(24.dp) + BodyM(stringResource(R.string.usdt__deposit_fee_note), color = Colors.White64) + VerticalSpacer(24.dp) + EstimateRow( + stringResource(R.string.usdt__receive_fee), if (address.amount >= address.estimatedReceived) { - (address.amount - address.estimatedReceived).usdtText(false) + usdtFormatAmount( + address.amount - address.estimatedReceived + ) } else { "—" } ) - BodyS(stringResource(R.string.usdt__deposit_estimate_note), color = Colors.White64) - VerticalSpacer(16.dp) - DepositField( - R.string.usdt__deposit_limits, - (address.minUsdCents?.usdCents() ?: "—") + " – " + (address.maxUsdCents?.usdCents() ?: "—") + EstimateRow(stringResource(R.string.usdt__receive_estimate), usdtFormatAmount(address.estimatedReceived)) + FillHeight() + PrimaryButton(stringResource(R.string.common__continue), onClick = { + onPage(ReceivePage.ADDRESS) + }, modifier = Modifier.testTag("UsdtReceiveFeesContinue")) + } + ReceivePage.ADDRESS -> { + val atomic = runCatching { PaykitAmount.parse(PaykitAsset.USDT, amount).atomic }.getOrNull() + val uri = if (atomic == null) wallet.receiveUri else wallet.receiveUri + "&uint256=$atomic" + UsdtReceiveContent( + address = state.address?.address ?: wallet.address, + uri = state.address?.uri ?: uri, + error = receiveError, + network = state.network?.label ?: "Arbitrum One", + onEdit = onRefresh, + onNetwork = { onPage(ReceivePage.NETWORKS) }, ) - BodyS(stringResource(R.string.usdt__deposit_limits_note), color = Colors.White64) - SecondaryButton(stringResource(R.string.usdt__deposit_refresh), onClick = onRefresh) - VerticalSpacer(16.dp) } - } else { - DepositAmount(amount, state.busy, state.error, state.amountLimits, onAmount, onCreate) } } @@ -334,88 +420,73 @@ private fun ColumnScope.DepositHistory( ) } +private enum class ReceivePage { ADDRESS, NETWORKS, AMOUNT, FEES } + @Composable -private fun NetworkSelector( +private fun ColumnScope.NetworkSelector( state: DepositUiState, onNetwork: (UsdtDepositNetwork?) -> Unit, onHistory: () -> Unit, ) { - Row(horizontalArrangement = Arrangement.SpaceBetween, modifier = Modifier.fillMaxWidth()) { - var menu by remember { mutableStateOf(false) } - Box { - NumberPadActionButton( - state.network?.label ?: "Arbitrum One", - onClick = { menu = true }, - enabled = !state.busy, - color = Colors.Green, - modifier = Modifier.testTag("UsdtReceiveNetwork") - ) - DropdownMenu( - expanded = menu, - onDismissRequest = { menu = false }, - containerColor = Colors.Gray6, - ) { - DropdownMenuItem(text = { BodySSB("Arbitrum One") }, onClick = { - menu = false - onNetwork(null) - }) - state.networks.forEach { network -> - DropdownMenuItem( - text = { BodySSB(network.label) }, - onClick = { - menu = false - onNetwork(network) - } - ) - } - } + Column( + verticalArrangement = Arrangement.spacedBy(8.dp), + modifier = Modifier.weight(1f).verticalScroll(rememberScrollState()) + ) { + NetworkRow("Arbitrum One", state.network == null, onClick = { onNetwork(null) }, isDefault = true) + state.networks.forEach { item -> + NetworkRow(item.label, state.network == item, onClick = { onNetwork(item) }) } + BodyS( + stringResource(R.string.usdt__receive_network_note), + color = Colors.White64, + modifier = Modifier.padding(vertical = 16.dp) + ) + UsdtCoinIllustration(modifier = Modifier.align(Alignment.CenterHorizontally)) if (Env.usdtDepositsUrl != null) { - TextButton( + TertiaryButton( + stringResource(R.string.usdt__deposit_history), onClick = onHistory, - enabled = !state.busy - ) { BodySSB(stringResource(R.string.usdt__activity), color = Colors.Green) } + modifier = Modifier.testTag("UsdtDepositHistory") + ) } + state.error?.let { BodyS(stringResource(it), color = Colors.White64) } } - VerticalSpacer(16.dp) } @Composable -private fun ColumnScope.DepositAmount( - amount: String, - busy: Boolean, - error: Int?, - limits: UsdtException.DepositAmountOutOfRange?, - onAmount: (String) -> Unit, - onCreate: () -> Unit, -) { - Caption13Up(stringResource(R.string.usdt__deposit_amount)) - VerticalSpacer(12.dp) - NumberPadAmountText(amount.ifEmpty { "0" }, "₮") - FillHeight() - val message = when { - limits != null && (limits.minUsdCents != null || limits.maxUsdCents != null) -> - stringResource(R.string.usdt__deposit_limits) + ": " + - (limits.minUsdCents?.usdCents() ?: "—") + " – " + (limits.maxUsdCents?.usdCents() ?: "—") - error != null -> stringResource(error) - else -> stringResource(R.string.usdt__deposit_fee_note) +private fun NetworkRow(title: String, selected: Boolean, onClick: () -> Unit, isDefault: Boolean = false) { + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(16.dp), + modifier = Modifier.fillMaxWidth().background( + Colors.Gray6, + RoundedCornerShape(16.dp) + ).clickableAlpha(onClick = onClick).padding(16.dp).testTag("UsdtNetwork-$title") + ) { + Image(painterResource(R.drawable.tether), null, modifier = Modifier.size(40.dp)) + BodyMSB(title) + if (isDefault) BodyS(stringResource(R.string.common__default), color = Colors.White64) + FillWidth() + if (selected) { + Icon( + painterResource(R.drawable.ic_check), + null, + tint = Colors.Usdt, + modifier = Modifier.size(24.dp) + ) + } } - BodyS(message, color = if (error == null) Colors.White64 else Colors.Brand) - VerticalSpacer(16.dp) - HorizontalDivider() - NumberPad( - type = NumberPadType.DECIMAL, - enabled = !busy, - onDeleteLongPress = { onAmount("") }, - onPress = { onAmount(NumberPadInputHandler.handleInput(it, amount, maxLength = 21, maxDecimals = 6)) }, - ) - PrimaryButton( - stringResource(R.string.usdt__deposit_create), - onClick = onCreate, - enabled = !busy && amount.isNotEmpty(), - isLoading = busy, - modifier = Modifier.testTag("UsdtDepositCreate") - ) +} + +@Composable +private fun EstimateRow(title: String, value: String) { + SendCell(caption = title, dividerSpacing = 24.dp) { + Row(horizontalArrangement = Arrangement.spacedBy(4.dp)) { + BodyMSB("± $", color = Colors.White64) + BodyMSB(value) + } + } + VerticalSpacer(24.dp) } @Composable @@ -508,7 +579,7 @@ private fun ULong?.usdtText(hidden: Boolean) = ( } ?: "—" } ) + " USDT" -private fun String.usdCents(locale: Locale = Locale.getDefault()): String = toULongOrNull()?.let { +internal fun String.usdCents(locale: Locale = Locale.getDefault()): String = toULongOrNull()?.let { val whole = NumberFormat.getIntegerInstance(locale).format((it / 100u).toLong()) "$$whole.${(it % 100u).toString().padStart(2, '0')}" } ?: "—" diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtReceiveAmountContent.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtReceiveAmountContent.kt new file mode 100644 index 0000000000..2f33416ec0 --- /dev/null +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtReceiveAmountContent.kt @@ -0,0 +1,232 @@ +package to.bitkit.ui.screens.wallets.usdt + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.BoxWithConstraints +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.ColumnScope +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.heightIn +import androidx.compose.foundation.layout.padding +import androidx.compose.material3.HorizontalDivider +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.testTag +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.unit.dp +import com.synonym.bitkitcore.UsdtException +import to.bitkit.R +import to.bitkit.ext.nowMillis +import to.bitkit.models.PaykitAmount +import to.bitkit.models.PaykitAmountError +import to.bitkit.models.PaykitAsset +import to.bitkit.models.PaykitExchangeRate +import to.bitkit.repositories.paykitRate +import to.bitkit.ui.LocalCurrencies +import to.bitkit.ui.components.BodyS +import to.bitkit.ui.components.Caption13Up +import to.bitkit.ui.components.FillWidth +import to.bitkit.ui.components.NumberPad +import to.bitkit.ui.components.NumberPadActionButton +import to.bitkit.ui.components.NumberPadAmountText +import to.bitkit.ui.components.NumberPadType +import to.bitkit.ui.components.PrimaryButton +import to.bitkit.ui.components.UsdtAmountHeader +import to.bitkit.ui.components.VerticalSpacer +import to.bitkit.ui.theme.Colors +import to.bitkit.ui.utils.NumberPadInputHandler + +@Composable +internal fun ColumnScope.UsdtReceiveAmountContent( + amount: String, + allowEmpty: Boolean, + busy: Boolean, + error: Int?, + limits: UsdtException.DepositAmountOutOfRange?, + onAmount: (String) -> Unit, + onContinue: () -> Unit, +) { + val currencies = LocalCurrencies.current + var bitcoinInput by remember { mutableStateOf(null) } + var conversionError by remember { mutableStateOf(null) } + val isSatsInput = bitcoinInput != null && currencies.displayUnit.isModern() + fun updateInput(value: String) { + conversionError = null + if (bitcoinInput == null) { + onAmount(value) + return + } + bitcoinInput = value + if (value.isEmpty()) { + onAmount("") + return + } + convertBitcoinInput(value, isSatsInput, currencies.paykitRate, onAmount) { conversionError = it } + } + Column(verticalArrangement = Arrangement.SpaceBetween, modifier = Modifier.heightIn(min = 156.dp)) { + ReceiveAmountHeader(amount, bitcoinInput) + Row( + verticalAlignment = Alignment.Bottom, + horizontalArrangement = Arrangement.spacedBy(16.dp), + modifier = Modifier.fillMaxWidth().padding(vertical = 16.dp) + ) { + val message = conversionError?.let { stringResource(it) } ?: depositAmountMessage(amount, limits, error) + if (message != null) BodyS(message, color = Colors.Brand, modifier = Modifier.weight(1f)) else FillWidth() + ReceiveUnitButton( + amount = amount, + bitcoinInput = bitcoinInput, + busy = busy, + onInput = { bitcoinInput = it }, + onError = { conversionError = it }, + ) + } + } + HorizontalDivider() + VerticalSpacer(24.dp) + ReceiveAmountKeypad(bitcoinInput, amount, isSatsInput, busy, ::updateInput, modifier = Modifier.weight(1f)) + VerticalSpacer(24.dp) + val validAmount = amount.isEmpty() && allowEmpty || runCatching { + PaykitAmount.parse(PaykitAsset.USDT, amount) + }.isSuccess + PrimaryButton( + stringResource(R.string.common__continue), + onClick = onContinue, + enabled = !busy && conversionError == null && validAmount, + isLoading = busy, + modifier = Modifier.testTag("UsdtDepositCreate") + ) +} + +@Composable +private fun depositAmountMessage(amount: String, limits: UsdtException.DepositAmountOutOfRange?, error: Int?): String? { + val value = amount.toBigDecimalOrNull() + val minText = limits?.minUsdCents + val min = minText?.toBigDecimalOrNull()?.movePointLeft(2) + val maxText = limits?.maxUsdCents + val max = maxText?.toBigDecimalOrNull()?.movePointLeft(2) + return when { + value != null && minText != null && min != null && value < min -> stringResource( + R.string.usdt__deposit_minimum, + minText.usdCents() + ) + value != null && maxText != null && max != null && value > max -> stringResource( + R.string.usdt__deposit_maximum, + maxText.usdCents() + ) + error != null -> stringResource(error) + else -> null + } +} + +private fun bitcoinAmount(value: String, isSatsInput: Boolean): PaykitAmount { + if (!isSatsInput) return PaykitAmount.parse(PaykitAsset.BTC, value) + val sats = value.toULongOrNull()?.takeIf { it > 0uL } ?: throw PaykitAmountError.InvalidAmount + return PaykitAmount(PaykitAsset.BTC, sats) +} + +@Composable +private fun ReceiveUnitButton( + amount: String, + bitcoinInput: String?, + busy: Boolean, + onInput: (String?) -> Unit, + onError: (Int?) -> Unit, +) { + val currencies = LocalCurrencies.current + NumberPadActionButton( + text = if (bitcoinInput == null) "USD" else "BTC", + icon = R.drawable.ic_transfer, + enabled = !busy, + color = Colors.Usdt, + modifier = Modifier.testTag("ReceiveNumberPadUnit"), + onClick = { + onError(null) + if (bitcoinInput != null) { + onInput(null) + } else if (amount.isEmpty() || amount == "0") { + onInput("") + } else { + try { + val bitcoin = PaykitAmount.parse(PaykitAsset.USDT, amount) + .convertedTo(PaykitAsset.BTC, currencies.paykitRate, nowMillis()) + // Switching display units preserves the exact USDT amount until the user edits it. + onInput(if (currencies.displayUnit.isModern()) bitcoin.atomic.toString() else bitcoin.value) + } catch (_: PaykitAmountError.RateUnavailable) { + onError(R.string.wallet__payment_request_rate_unavailable) + } catch (_: PaykitAmountError) { + onError(R.string.usdt__error_amount) + } + } + }, + ) +} + +private fun convertBitcoinInput( + value: String, + isSatsInput: Boolean, + rate: PaykitExchangeRate?, + onAmount: (String) -> Unit, + onError: (Int) -> Unit, +) { + try { + onAmount( + bitcoinAmount(value, isSatsInput).convertedTo(PaykitAsset.USDT, rate, nowMillis()).value + ) + } catch (_: PaykitAmountError.RateUnavailable) { + onError(R.string.wallet__payment_request_rate_unavailable) + } catch (_: PaykitAmountError) { + onError(R.string.usdt__error_amount) + } +} + +@Composable +private fun ReceiveAmountHeader(amount: String, bitcoinInput: String?) { + if (bitcoinInput == null) { + UsdtAmountHeader(amount.ifEmpty { "0" }, "Arbitrum One") + } else { + Column { + Caption13Up("$ " + amount.ifEmpty { "0" }, color = Colors.White64) + VerticalSpacer(16.dp) + NumberPadAmountText(bitcoinInput.ifEmpty { "0" }, "₿") + } + } +} + +@Composable +private fun ReceiveAmountKeypad( + bitcoinInput: String?, + amount: String, + isSatsInput: Boolean, + busy: Boolean, + onInput: (String) -> Unit, + modifier: Modifier = Modifier, +) { + val decimals = when { + isSatsInput -> 0 + bitcoinInput == null -> PaykitAsset.USDT.decimals + else -> PaykitAsset.BTC.decimals + } + BoxWithConstraints(modifier = modifier.fillMaxWidth()) { + NumberPad( + type = if (isSatsInput) NumberPadType.INTEGER else NumberPadType.DECIMAL, + availableHeight = maxHeight, + enabled = !busy, + onDeleteLongPress = { onInput("") }, + onPress = { + onInput( + NumberPadInputHandler.handleInput( + it, + bitcoinInput ?: amount, + maxLength = 21, + maxDecimals = decimals, + ) + ) + }, + ) + } +} diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtReceiveContent.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtReceiveContent.kt index 6fb2e9a32d..4f20e02ff4 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtReceiveContent.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtReceiveContent.kt @@ -1,10 +1,12 @@ package to.bitkit.ui.screens.wallets.usdt +import androidx.compose.foundation.background import androidx.compose.foundation.layout.BoxWithConstraints import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.ColumnScope import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.size import androidx.compose.foundation.rememberScrollState import androidx.compose.foundation.verticalScroll @@ -15,21 +17,22 @@ import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.saveable.rememberSaveable import androidx.compose.runtime.setValue import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip import androidx.compose.ui.platform.testTag import androidx.compose.ui.res.painterResource import androidx.compose.ui.res.stringResource -import androidx.compose.ui.text.style.TextOverflow import androidx.compose.ui.unit.dp import to.bitkit.R import to.bitkit.ui.components.BodyS import to.bitkit.ui.components.ButtonSize import to.bitkit.ui.components.GradientCircularProgressIndicator import to.bitkit.ui.components.PrimaryButton -import to.bitkit.ui.components.TertiaryButton +import to.bitkit.ui.components.SecondaryButton import to.bitkit.ui.components.VerticalSpacer import to.bitkit.ui.screens.wallets.receive.CopyAddressCard import to.bitkit.ui.screens.wallets.receive.CopyAddressType import to.bitkit.ui.screens.wallets.receive.ReceiveQrView +import to.bitkit.ui.theme.AppShapes import to.bitkit.ui.theme.Colors @Composable @@ -37,40 +40,39 @@ internal fun ColumnScope.UsdtReceiveContent( address: String, uri: String, error: Int?, - warning: Int = R.string.usdt__receive_warning, - details: @Composable () -> Unit = {}, + network: String, + onEdit: () -> Unit, + onNetwork: () -> Unit, ) { var showDetails by rememberSaveable { mutableStateOf(false) } - Column(modifier = Modifier.weight(1f).verticalScroll(rememberScrollState())) { + BoxWithConstraints(modifier = Modifier.weight(1f).fillMaxWidth()) { if (uri.isNotEmpty()) { if (showDetails) { - CopyAddressCard( - title = stringResource(R.string.usdt__address), - address = address, - type = CopyAddressType.ONCHAIN, - onClickEditInvoice = null, - testTag = "UsdtReceiveAddress", - accentColor = Colors.Green, - ) - } else { - BoxWithConstraints(modifier = Modifier.fillMaxWidth()) { - ReceiveQrView( - uri = uri, - copyText = address, - qrLogoPainter = null, + Column( + modifier = Modifier.fillMaxWidth().height(minOf(maxWidth, maxHeight)) + .clip(AppShapes.small).background(Colors.Black) + .verticalScroll(rememberScrollState()).padding(32.dp) + ) { + CopyAddressCard( + title = network + " " + stringResource(R.string.wallet__activity_address), + address = address, + type = CopyAddressType.ONCHAIN, onClickEditInvoice = null, - accentColor = Colors.Green, - shareContent = uri, - modifier = Modifier.fillMaxWidth().height(maxWidth + ButtonSize.Small.height + 32.dp) + testTag = "UsdtReceiveAddress", + accentColor = Colors.Usdt, ) } - VerticalSpacer(16.dp) - BodyS( - address, - color = Colors.White64, - maxLines = 1, - overflow = TextOverflow.MiddleEllipsis, - modifier = Modifier.testTag("UsdtReceiveAddress") + } else { + ReceiveQrView( + uri = uri, + copyText = address, + qrLogoPainter = painterResource(R.drawable.tether_circle), + onClickEditInvoice = onEdit, + accentColor = Colors.Usdt, + shareContent = uri, + modifier = Modifier.fillMaxWidth().height( + minOf(maxHeight, maxWidth + ButtonSize.Small.height + 32.dp) + ) ) } } else if (error != null) { @@ -78,29 +80,37 @@ internal fun ColumnScope.UsdtReceiveContent( } else { GradientCircularProgressIndicator(modifier = Modifier.size(24.dp)) } - VerticalSpacer(16.dp) - details() - BodyS(stringResource(warning), color = Colors.White64) } - if (showDetails) { - PrimaryButton( - text = stringResource(R.string.wallet__receive_show_qr), - icon = { + SecondaryButton( + text = stringResource(R.string.usdt__receive_network, network), + onClick = onNetwork, + size = ButtonSize.Small, + icon = { + Icon( + painterResource(R.drawable.usdt_network), + null, + tint = Colors.Usdt, + modifier = Modifier.size(16.dp) + ) + }, + modifier = Modifier.testTag("UsdtReceiveNetwork") + ) + VerticalSpacer(16.dp) + PrimaryButton( + text = stringResource(if (showDetails) R.string.wallet__receive_show_qr else R.string.common__show_details), + icon = if (showDetails) { + { Icon( painter = painterResource(R.drawable.ic_qr_purple), contentDescription = null, tint = Colors.White, modifier = Modifier.size(16.dp) ) - }, - onClick = { showDetails = false }, - modifier = Modifier.testTag("UsdtReceiveDetails") - ) - } else { - TertiaryButton( - text = stringResource(R.string.common__show_details), - onClick = { showDetails = true }, - modifier = Modifier.testTag("UsdtReceiveDetails") - ) - } + } + } else { + null + }, + onClick = { showDetails = !showDetails }, + modifier = Modifier.testTag("UsdtReceiveDetails") + ) } diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtSendContent.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtSendContent.kt index 136449957c..926222de6f 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtSendContent.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtSendContent.kt @@ -2,6 +2,7 @@ package to.bitkit.ui.screens.wallets.usdt import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.BoxWithConstraints import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.ColumnScope import androidx.compose.foundation.layout.Row @@ -237,7 +238,7 @@ private fun UsdtNetwork( NumberPadActionButton( destination.label, onClick = { expanded = true }, - color = Colors.Green, + color = Colors.Usdt, modifier = Modifier.testTag("UsdtNetwork") ) DropdownMenu( @@ -279,7 +280,7 @@ private fun UsdtRecipientContent( RectangleButton( label = stringResource(R.string.wallet__payment_request_paste), icon = R.drawable.ic_clipboard_text, - iconTint = Colors.Green, + iconTint = Colors.Usdt, modifier = Modifier.testTag("UsdtPaste") ) { val value = context.getClipboardText()?.trim() @@ -293,7 +294,7 @@ private fun UsdtRecipientContent( RectangleButton( label = stringResource(R.string.wallet__recipient_manual), icon = R.drawable.ic_pencil_simple, - iconTint = Colors.Green, + iconTint = Colors.Usdt, modifier = Modifier.testTag("UsdtManual") ) { onPageChange(UsdtPage.MANUAL) } error?.let { @@ -359,8 +360,8 @@ private fun UsdtAmountContent( Column(modifier = Modifier.fillMaxSize()) { Caption13Up("USDT · " + destination.label, color = Colors.White64) VerticalSpacer(8.dp) - NumberPadAmountText(value = amount.ifEmpty { "0" }, symbol = "₮", modifier = Modifier.testTag("UsdtAmount")) - FillHeight() + NumberPadAmountText(value = amount.ifEmpty { "0" }, symbol = "$", modifier = Modifier.testTag("UsdtAmount")) + VerticalSpacer(32.dp) state.error?.let { BodyS(stringResource(it), color = Colors.Brand, modifier = Modifier.testTag("UsdtError")) VerticalSpacer(16.dp) @@ -368,7 +369,7 @@ private fun UsdtAmountContent( Row(verticalAlignment = Alignment.Bottom) { Column(modifier = Modifier.weight(1f)) { Caption13Up(stringResource(R.string.usdt__balance), color = Colors.White64) - VerticalSpacer(4.dp) + VerticalSpacer(8.dp) BodySSB( ( if (hideBalance) { @@ -381,18 +382,21 @@ private fun UsdtAmountContent( ) + " USDT" ) } - NumberPadActionButton(text = "USDT", color = Colors.Green, enabled = false, onClick = {}) + NumberPadActionButton(text = "USDT", color = Colors.Usdt, enabled = false, onClick = {}) } - VerticalSpacer(12.dp) + VerticalSpacer(16.dp) HorizontalDivider() - NumberPad( - type = NumberPadType.DECIMAL, - enabled = !state.busy && amountEditable, - onDeleteLongPress = { onAmountChange("") }, - onPress = { key -> - onAmountChange(NumberPadInputHandler.handleInput(key, amount, maxLength = 21, maxDecimals = 6)) - }, - ) + BoxWithConstraints(contentAlignment = Alignment.Center, modifier = Modifier.weight(1f).fillMaxWidth()) { + NumberPad( + type = NumberPadType.DECIMAL, + availableHeight = maxHeight, + enabled = !state.busy && amountEditable, + onDeleteLongPress = { onAmountChange("") }, + onPress = { key -> + onAmountChange(NumberPadInputHandler.handleInput(key, amount, maxLength = 21, maxDecimals = 6)) + }, + ) + } VerticalSpacer(16.dp) PrimaryButton( text = stringResource(R.string.common__continue), @@ -415,7 +419,7 @@ private fun UsdtConfirmation(quote: UsdtQuote, state: UsdtSendState, onConfirm: quote.destination.label, onClick = { if (!state.busy) onEditAmount() } ) - VerticalSpacer(32.dp) + VerticalSpacer(44.dp) if (showDetails) { UsdtQuoteDetails(quote) } else if (quote.destination == UsdtDestination.ARBITRUM) { @@ -484,7 +488,7 @@ private fun UsdtConfirmation(quote: UsdtQuote, state: UsdtSendState, onConfirm: Icon( painterResource(if (showDetails) R.drawable.ic_eye_slash else R.drawable.ic_coins), null, - tint = Colors.Green, + tint = Colors.Usdt, modifier = Modifier.size(16.dp) ) }, @@ -494,7 +498,7 @@ private fun UsdtConfirmation(quote: UsdtQuote, state: UsdtSendState, onConfirm: ) SwipeToConfirm( text = stringResource(R.string.wallet__send_swipe), - color = Colors.Green, + color = Colors.Usdt, onConfirm = onConfirm, enabled = !state.busy, loading = state.busy, @@ -509,7 +513,7 @@ private fun UsdtConfirmation(quote: UsdtQuote, state: UsdtSendState, onConfirm: private fun UsdtQuoteDetails(quote: UsdtQuote) { Row(horizontalArrangement = Arrangement.spacedBy(16.dp)) { SendCell(caption = stringResource(R.string.wallet__send_from), modifier = Modifier.weight(1f)) { - NumberPadActionButton(text = "USDT", color = Colors.Green, enabled = false, onClick = {}) + NumberPadActionButton(text = "USDT", color = Colors.Usdt, enabled = false, onClick = {}) } SendCell(caption = stringResource(R.string.usdt__destination), modifier = Modifier.weight(1f)) { BodySSB(quote.destination.label, modifier = Modifier.height(28.dp)) @@ -519,8 +523,8 @@ private fun UsdtQuoteDetails(quote: UsdtQuote) { SendCell( caption = stringResource(R.string.wallet__send_to) ) { SelectionContainer { BodySSB(quote.recipient) } } - VerticalSpacer(16.dp) quote.bridgeProvider?.let { provider -> + VerticalSpacer(16.dp) SendCell(caption = stringResource(R.string.usdt__bridge_provider)) { BodySSB(if (provider == UsdtBridgeProvider.ORCHESTRA) "Orchestra" else "USDT0") } diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtWalletScreen.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtWalletScreen.kt index 332703a6d6..6283577313 100644 --- a/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtWalletScreen.kt +++ b/app/src/main/java/to/bitkit/ui/screens/wallets/usdt/UsdtWalletScreen.kt @@ -1,21 +1,27 @@ package to.bitkit.ui.screens.wallets.usdt import androidx.activity.compose.BackHandler +import androidx.compose.foundation.Image import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.IntrinsicSize import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.WindowInsets +import androidx.compose.foundation.layout.asPaddingValues import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.height import androidx.compose.foundation.layout.imePadding import androidx.compose.foundation.layout.navigationBarsPadding +import androidx.compose.foundation.layout.offset import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.requiredSize import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.statusBars import androidx.compose.foundation.lazy.LazyColumn import androidx.compose.foundation.lazy.itemsIndexed import androidx.compose.material3.ExperimentalMaterial3Api -import androidx.compose.material3.Icon import androidx.compose.material3.SheetValue import androidx.compose.material3.VerticalDivider import androidx.compose.material3.rememberModalBottomSheetState @@ -28,7 +34,10 @@ import androidx.compose.runtime.remember import androidx.compose.runtime.rememberUpdatedState import androidx.compose.runtime.saveable.rememberSaveable import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.scale +import androidx.compose.ui.layout.ContentScale import androidx.compose.ui.platform.testTag import androidx.compose.ui.res.painterResource import androidx.compose.ui.res.stringResource @@ -57,17 +66,17 @@ import to.bitkit.ui.components.BodyS import to.bitkit.ui.components.BottomSheet import to.bitkit.ui.components.Caption13Up import to.bitkit.ui.components.FillWidth -import to.bitkit.ui.components.PrimaryButton -import to.bitkit.ui.components.SecondaryButton +import to.bitkit.ui.components.Sheet +import to.bitkit.ui.components.TabBar import to.bitkit.ui.components.UsdtAmountHeader import to.bitkit.ui.components.VerticalSpacer import to.bitkit.ui.components.WalletBalanceContent +import to.bitkit.ui.components.usdtOverviewAmount import to.bitkit.ui.scaffold.AppAlertDialog import to.bitkit.ui.scaffold.AppTopBar import to.bitkit.ui.scaffold.DrawerNavIcon -import to.bitkit.ui.screens.wallets.activity.components.CircularIcon -import to.bitkit.ui.screens.wallets.activity.components.EmptyActivityRow import to.bitkit.ui.screens.wallets.activity.components.activityGroupTitleResource +import to.bitkit.ui.screens.wallets.receive.ReceiveTab import to.bitkit.ui.screens.wallets.send.SendPinCheckScreen import to.bitkit.ui.settingsViewModel import to.bitkit.ui.shared.UiConstants @@ -84,28 +93,29 @@ fun UsdtWalletCard(onClick: () -> Unit, viewModel: UsdtViewModel = hiltViewModel val wallet by viewModel.wallet.collectAsStateWithLifecycle() val settings by viewModel.settings.collectAsStateWithLifecycle() UsdtRefreshEffect(viewModel, pending = wallet.transfers.any { it.status == UsdtTransferStatus.PENDING }) - VerticalSpacer(16.dp) - Row(modifier = Modifier.fillMaxWidth().height(IntrinsicSize.Min)) { + VerticalSpacer(24.dp) + Row( + horizontalArrangement = Arrangement.spacedBy(16.dp), + modifier = Modifier.fillMaxWidth().height(IntrinsicSize.Min) + ) { WalletBalanceContent( title = "USDT", icon = { - CircularIcon( - icon = painterResource(R.drawable.ic_coins), - iconColor = Colors.Green, - backgroundColor = Colors.Green16, - size = 24.dp, - modifier = Modifier.padding(end = 4.dp) + Image( + painterResource(R.drawable.tether_circle), + contentDescription = null, + modifier = Modifier.size(24.dp) ) }, modifier = Modifier.clickableAlpha(onClick = onClick).padding(vertical = 4.dp) - .padding(end = 8.dp).testTag("UsdtWallet"), + .testTag("UsdtWallet"), ) { BodyMSB( if (settings.hideBalance) { UiConstants.HIDE_BALANCE_SHORT } else { wallet.balance?.let { - usdtFormatAmount(it) + usdtOverviewAmount(it) } ?: "—" } ) @@ -118,7 +128,12 @@ fun UsdtWalletCard(onClick: () -> Unit, viewModel: UsdtViewModel = hiltViewModel @Suppress("CyclomaticComplexMethod") @OptIn(ExperimentalMaterial3Api::class) @Composable -fun UsdtWalletScreen(onBack: () -> Unit, viewModel: UsdtViewModel = hiltViewModel()) { +fun UsdtWalletScreen( + onBack: () -> Unit, + initialTransferId: String? = null, + viewModel: UsdtViewModel = hiltViewModel() +) { + val app = appViewModel val wallet by viewModel.wallet.collectAsStateWithLifecycle() val state by viewModel.state.collectAsStateWithLifecycle() val settings by viewModel.settings.collectAsStateWithLifecycle() @@ -128,13 +143,12 @@ fun UsdtWalletScreen(onBack: () -> Unit, viewModel: UsdtViewModel = hiltViewMode viewModel.isSendPresented = sending onDispose { viewModel.isSendPresented = false } } - var selectedTransferId by rememberSaveable { mutableStateOf(null) } + var selectedTransferId by rememberSaveable(initialTransferId) { mutableStateOf(initialTransferId) } var recipient by remember { mutableStateOf("") } var amount by remember { mutableStateOf("") } val destinations by viewModel.destinations.collectAsStateWithLifecycle() var destination by remember { mutableStateOf(UsdtDestination.ARBITRUM) } - var depositBlocking by remember { mutableStateOf(false) } - val dismissalBlocked = state.busy || state.authenticationRequired || depositBlocking + val dismissalBlocked = state.busy || state.authenticationRequired val dismiss = { if (!dismissalBlocked) { viewModel.edit() @@ -155,7 +169,7 @@ fun UsdtWalletScreen(onBack: () -> Unit, viewModel: UsdtViewModel = hiltViewMode } } BackHandler(enabled = page == UsdtPage.WALLET) { - if (selectedTransferId != null) selectedTransferId = null else onBack() + if (selectedTransferId != null && initialTransferId == null) selectedTransferId = null else onBack() } val lifecycle = LocalLifecycleOwner.current.lifecycle LaunchedEffect(lifecycle, state.submitted) { @@ -170,14 +184,14 @@ fun UsdtWalletScreen(onBack: () -> Unit, viewModel: UsdtViewModel = hiltViewMode UsdtRefreshEffect( viewModel, pending = wallet.transfers.any { it.status == UsdtTransferStatus.PENDING }, - receiving = page == UsdtPage.RECEIVE, ) { - if (page == UsdtPage.RECEIVE && !depositBlocking) page = UsdtPage.WALLET page == UsdtPage.WALLET } val selectedTransfer = wallet.transfers.firstOrNull { it.id == selectedTransferId } if (selectedTransfer != null) { - UsdtActivityDetail(selectedTransfer, settings.hideBalance) { selectedTransferId = null } + UsdtActivityDetail(selectedTransfer, settings.hideBalance) { + if (initialTransferId == null) selectedTransferId = null else onBack() + } } else { UsdtWalletContent( wallet = wallet, @@ -185,7 +199,7 @@ fun UsdtWalletScreen(onBack: () -> Unit, viewModel: UsdtViewModel = hiltViewMode hideBalance = settings.hideBalance, onReceive = { viewModel.edit() - page = UsdtPage.RECEIVE + app?.showSheet(Sheet.Receive(initialTab = ReceiveTab.USDT)) }, onSend = { recipient = "" @@ -229,11 +243,7 @@ fun UsdtWalletScreen(onBack: () -> Unit, viewModel: UsdtViewModel = hiltViewMode onCancel = viewModel::cancelAuthentication, onVerified = viewModel::authenticationVerified, ) - page == UsdtPage.RECEIVE -> UsdtDepositReceiveScreen( - viewModel = viewModel, - onBack = back, - onBlockingChange = { depositBlocking = it } - ) + else -> UsdtPaymentContent( wallet = wallet, state = state, page = page, recipient = recipient, amount = amount, destination = destination, @@ -289,64 +299,77 @@ private fun UsdtWalletContent( onActivityClick: (UsdtTransfer) -> Unit = {}, ) { val settings = settingsViewModel + val app = appViewModel val allowSwipe by settings?.enableSwipeToHideBalance?.collectAsStateWithLifecycle() ?: remember { mutableStateOf(false) } - Column(modifier = Modifier.fillMaxSize()) { - AppTopBar(titleText = "USDT", onBackClick = onBack, actions = { DrawerNavIcon() }) - LazyColumn(modifier = Modifier.padding(horizontal = 16.dp)) { - item { - VerticalSpacer(16.dp) - UsdtAmountHeader( - amount = wallet.balance?.let { usdtFormatAmount(it) } ?: "—", - network = "Arbitrum One", - hideBalance = hideBalance, - onToggleHide = if (allowSwipe) ({ settings?.setHideBalance(!hideBalance) }) else null, - modifier = Modifier.testTag("UsdtBalance") - ) - VerticalSpacer(32.dp) - Row(horizontalArrangement = Arrangement.spacedBy(16.dp)) { - SecondaryButton( - text = stringResource(R.string.usdt__receive), - onClick = onReceive, - icon = { Icon(painterResource(R.drawable.ic_received), null, tint = Colors.Green) }, - modifier = Modifier.weight(1f).testTag("UsdtReceive") - ) - PrimaryButton( - text = stringResource(R.string.usdt__send), - onClick = onSend, - icon = { Icon(painterResource(R.drawable.ic_sent), null, tint = Colors.Green) }, - modifier = Modifier.weight(1f).testTag("UsdtSend") - ) - } - VerticalSpacer(32.dp) - error?.let { - BodyS(stringResource(it), color = Colors.Brand) + Box(modifier = Modifier.fillMaxSize()) { + UsdtCoinIllustration( + modifier = Modifier.align(Alignment.TopEnd) + .offset(x = 81.dp, y = WindowInsets.statusBars.asPaddingValues().calculateTopPadding() + 4.dp) + .scale(scaleX = -1f, scaleY = 1f) + ) + Column { + AppTopBar( + titleText = "USDT", + onBackClick = onBack, + icon = R.drawable.tether_circle, + actions = { DrawerNavIcon() } + ) + LazyColumn(modifier = Modifier.padding(horizontal = 16.dp)) { + item { VerticalSpacer(16.dp) + UsdtAmountHeader( + amount = wallet.balance?.let { usdtFormatAmount(it) } ?: "—", + network = "Arbitrum One", + hideBalance = hideBalance, + onToggleHide = if (allowSwipe) ({ settings?.setHideBalance(!hideBalance) }) else null, + modifier = Modifier.testTag("UsdtBalance") + ) + VerticalSpacer(32.dp) + error?.let { + BodyS(stringResource(it), color = Colors.Brand) + VerticalSpacer(16.dp) + } } - if (wallet.transfers.isEmpty()) { - Caption13Up(stringResource(R.string.usdt__activity), color = Colors.White64) + itemsIndexed(wallet.transfers, key = { _, transfer -> transfer.id }) { index, transfer -> + val heading = activityGroupTitleResource(transfer.timestamp) + if (index == 0 || activityGroupTitleResource(wallet.transfers[index - 1].timestamp) != heading) { + Caption13Up( + stringResource(heading), + color = Colors.White64, + modifier = Modifier.padding(top = if (index == 0) 0.dp else 16.dp, bottom = 16.dp) + ) + } + UsdtActivityRow(transfer, hideBalance, onClick = { onActivityClick(transfer) }) VerticalSpacer(16.dp) - EmptyActivityRow(onClick = onReceive) } - } - itemsIndexed(wallet.transfers, key = { _, transfer -> transfer.id }) { index, transfer -> - val heading = activityGroupTitleResource(transfer.timestamp) - if (index == 0 || activityGroupTitleResource(wallet.transfers[index - 1].timestamp) != heading) { - Caption13Up( - stringResource(heading), - color = Colors.White64, - modifier = Modifier.padding(vertical = 8.dp) - ) + item { + if (!wallet.historyComplete) { + BodyS( + stringResource(R.string.usdt__history_sync), + color = Colors.White64 + ) + } + VerticalSpacer(120.dp) } - UsdtActivityRow(transfer, hideBalance, onClick = { onActivityClick(transfer) }) - VerticalSpacer(16.dp) - } - item { - if (!wallet.historyComplete) BodyS(stringResource(R.string.usdt__history_sync), color = Colors.White64) - VerticalSpacer(120.dp) } } + TabBar(onSendClick = onSend, onReceiveClick = onReceive, onScanClick = { + app?.showScannerSheet(showBackButton = false) + }) + } +} + +@Composable +internal fun UsdtCoinIllustration(modifier: Modifier = Modifier) { + Box(contentAlignment = Alignment.Center, modifier = modifier.size(256.dp)) { + Image( + painterResource(R.drawable.tether_coin), + contentDescription = null, + contentScale = ContentScale.Crop, + modifier = Modifier.requiredSize(width = 304.76.dp, height = 228.57.dp) + ) } } @@ -363,7 +386,7 @@ internal val UsdtDestination.label: String get() = when (this) { } @Composable -private fun UsdtRefreshEffect( +internal fun UsdtRefreshEffect( viewModel: UsdtViewModel, pending: Boolean = false, receiving: Boolean = false, @@ -378,12 +401,13 @@ private fun UsdtRefreshEffect( lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) { launch { viewModel.receivedTxs.collect { transfer -> - if (handleReceived()) { + if ((isReceiving || app?.currentSheet?.value == null) && handleReceived()) { app?.showTransactionSheet( NewTransactionSheetDetails( type = NewTransactionSheetType.ONCHAIN, direction = NewTransactionSheetDirection.RECEIVED, usdtAmount = transfer.amount, + usdtTransferId = transfer.id, ) ) } @@ -410,7 +434,6 @@ internal fun UsdtAuthentication(useBiometrics: Boolean, onCancel: () -> Unit, on internal enum class UsdtPage { WALLET, - RECEIVE, RECIPIENT, MANUAL, AMOUNT, diff --git a/app/src/main/java/to/bitkit/ui/sheets/NewTransactionSheet.kt b/app/src/main/java/to/bitkit/ui/sheets/NewTransactionSheet.kt index 9c00d00b63..af1555c283 100644 --- a/app/src/main/java/to/bitkit/ui/sheets/NewTransactionSheet.kt +++ b/app/src/main/java/to/bitkit/ui/sheets/NewTransactionSheet.kt @@ -108,7 +108,7 @@ fun NewTransactionSheetView( rememberLottieDynamicProperties( rememberLottieDynamicProperty( property = LottieProperty.COLOR, - value = Colors.Green.toArgb(), + value = Colors.Usdt.toArgb(), keyPath = arrayOf("**"), ) ) @@ -187,42 +187,56 @@ fun NewTransactionSheetView( Spacer(modifier = Modifier.weight(1f)) - if (details.direction == NewTransactionSheetDirection.SENT) { - Row( - horizontalArrangement = Arrangement.spacedBy(16.dp), - modifier = Modifier - .fillMaxWidth() - .testTag("sent_buttons_row") - ) { - SecondaryButton( - text = stringResource(R.string.wallet__send_details), - onClick = onDetailClick, - enabled = (details.activityId != null || details.paymentHashOrTxId != null) && - !details.isLoadingDetails, - modifier = Modifier - .weight(1f) - .testTag("Details") - ) - PrimaryButton( - text = stringResource(R.string.common__close), - onClick = onCloseClick, - modifier = Modifier - .weight(1f) - .testTag("Close") - ) - } - } else { - PrimaryButton( - text = localizedRandom(R.string.common__ok_random), - onClick = onCloseClick, - modifier = Modifier.testTag("ReceivedTransactionButton") - ) - } + TransactionButtons(details, onCloseClick, onDetailClick) Spacer(modifier = Modifier.height(8.dp)) } } } +@Composable +private fun TransactionButtons( + details: NewTransactionSheetDetails, + onCloseClick: () -> Unit, + onDetailClick: () -> Unit +) { + if (details.direction == NewTransactionSheetDirection.SENT || details.usdtTransferId != null) { + Row( + horizontalArrangement = Arrangement.spacedBy(16.dp), + modifier = Modifier + .fillMaxWidth() + .testTag("sent_buttons_row") + ) { + SecondaryButton( + text = stringResource(R.string.wallet__send_details), + onClick = onDetailClick, + enabled = !details.isLoadingDetails && ( + details.activityId != null || details.paymentHashOrTxId != null || details.usdtTransferId != null + ), + modifier = Modifier + .weight(1f) + .testTag("Details") + ) + PrimaryButton( + text = if (details.direction == NewTransactionSheetDirection.RECEIVED) { + localizedRandom(R.string.common__ok_random) + } else { + stringResource(R.string.common__close) + }, + onClick = onCloseClick, + modifier = Modifier + .weight(1f) + .testTag("Close") + ) + } + } else { + PrimaryButton( + text = localizedRandom(R.string.common__ok_random), + onClick = onCloseClick, + modifier = Modifier.testTag("ReceivedTransactionButton") + ) + } +} + @Preview(showSystemUi = true) @Composable private fun Preview() { diff --git a/app/src/main/java/to/bitkit/ui/theme/Colors.kt b/app/src/main/java/to/bitkit/ui/theme/Colors.kt index 58a6d4917f..4020d7fb7a 100644 --- a/app/src/main/java/to/bitkit/ui/theme/Colors.kt +++ b/app/src/main/java/to/bitkit/ui/theme/Colors.kt @@ -6,6 +6,7 @@ object Colors { // Accents val Brand = Color(0xFFFF4400) val Blue = Color(0xFF0085FF) + val Usdt = Color(0xFF009393) val Green = Color(0xFF75BF72) val Purple = Color(0xFFB95CE8) val Red = Color(0xFFE95164) @@ -48,6 +49,7 @@ object Colors { val Brand24 = Brand.copy(alpha = 0.24f) val Brand32 = Brand.copy(alpha = 0.32f) val Brand50 = Brand.copy(alpha = 0.50f) + val Usdt16 = Usdt.copy(alpha = 0.16f) val Green16 = Green.copy(alpha = 0.16f) val Green24 = Green.copy(alpha = 0.24f) val Green32 = Green.copy(alpha = 0.32f) diff --git a/app/src/main/java/to/bitkit/viewmodels/AppViewModel.kt b/app/src/main/java/to/bitkit/viewmodels/AppViewModel.kt index 0383031c1c..0992601c79 100644 --- a/app/src/main/java/to/bitkit/viewmodels/AppViewModel.kt +++ b/app/src/main/java/to/bitkit/viewmodels/AppViewModel.kt @@ -5696,6 +5696,11 @@ class AppViewModel @Inject constructor( fun onClickActivityDetail() { val details = _transactionSheet.value + details.usdtTransferId?.let { + hideNewTransactionSheet() + navigateToUsdtActivity(it) + return + } details.activityId?.let { hideNewTransactionSheet() mainScreenEffect( @@ -5823,6 +5828,13 @@ class AppViewModel @Inject constructor( fun resetQuickPay() = _quickPayData.update { null } + fun navigateToUsdtActivity(transferId: String) { + viewModelScope.launch { + hideSheet() + mainScreenEffect(MainScreenEffect.Navigate(Routes.UsdtActivity(transferId))) + } + } + fun navigateToActivity(activityRawId: String, walletId: String? = null) { viewModelScope.launch { hideSheet() diff --git a/app/src/main/res/drawable-nodpi/tether.png b/app/src/main/res/drawable-nodpi/tether.png new file mode 100644 index 0000000000000000000000000000000000000000..ccff3ff97ece660346fcf873edf2ffe7b9b46117 GIT binary patch literal 2762 zcmV;*3N`hKP)^9d`Uz>RCt{2oqKRpcNNEf(Bh~geOYmQTd0n2i?$t|vFfO!)jHY& zt?eJST5BD3eAPNSDr{T-aAHj}d(LJvYaoG!BoH1UB#>5KB@)0iKp+Gs2}whs$!Z?D3$351{Wy5f0+XCDS%Q1 za7ZDxD}ZwfU_>F3rv)%#)MC6QT$>VwxI!T=HEQR`$j!Y&AwH)N8x=rYyvR-!7`5XX zW-G+om94|?zfK`OsQ^xh7tXzEGHRTaHDB2#va@ee08dX0W6}lkhQO%xQz{s|QOZeKM=T8A=cWU09t6&V4w2)7g=LI;(ZFSUl$+k2H&7U zd@ysy^DqODV}lFT!WnA79fRppg3tGsiT+dmejV?Yq6~L18rUO0alj8;OY-;8s-Y=fK7MTRWL&=%XJte?-Z2-ChLiREkT$s$f zuNQgHb*eGEOzhHJ3m>ihY6 zOP4$VVBhrT3HYFad~#Z7Ne!Nu4uD2&0D1+$rs>Y`NhhU+7S_P;Up)2h=L4MD0QBk- zF~D*0gtW+F0FI2C&u7o|(QWb^fb4lFbThYq%fyq>A|VKt@cjRjHUPZ|A;5B;|4YRa z(ITN5tmP4)UK@bkgb<*PM}Q9TM6^h#2JLF%?GkMQdawq(^Q#bt#S_sYp&DFb0JH(< z;Tni1phX%04FTy9U=|4G<>t~~4jiC;U0qZki8w+P?d|mCO`GgJ%84hCpz@oV$cZsB zHb!@rm5JBS(E!}FX%ofCxpBCshvo(X;&pT+0N3W`($TYL$?5UPjveB)bR+p~&%dO8Y#4-^*C(8vh6CH_`dCtg!W0kFBPjocKm%a`fHYu1R@)e!)EtD=J3 z80%VE#A|DN0N$3DM{NTGgtjz=;@&$(FLE##fwSh`*I{=pSDmu zfj8;a=bty`%4FjA`}T?Ej7N`>W7|UU1m2|W9UVy*(}@6t?a~&CCon}1zVJfQg>)(a zwrLB+6PVEaP>9Z4xIkV4AZCZQP}=xOZM3hUfF^ z*C(uZuUa)@J|A4YI;qcF-`bjT?!3wMrHvcC3&0#is_p6`D`U11BXI1PcXkV<0eEcJ zF0wl827qW=C~5vp`T5k7*%|cmGqNcyJ*G1gY>WC z$LYV}FkQ&d7WKu^QTov8)$Rv?Px&0_?KQ1%+(GaP;xAu%i9S(Wobmjx2?UI%e;!E~ zG&3=_ye*Uf;I}n3rrj}rudk;CD_2^64Qh&bF^5NobXr-lw$SQgy)_u5v$0s(g^G@j z(jDv9&)8lrT(gG0S5-xi@7`?;;k;n8@#INbR$V<~j=$Qwmr7e&$luUl97X@}#1!)W z!onGU?)z0$WJXkY{<+;fy>4o{hz5=jqe*&%=l5 zYvtv}bTIX2kC||QwL2PhF92`P%QNL6s<^q?_&gpi`EDJY!SGCW0ll%9(an5v;@RUs zcQ>UQ{5<1Y09ZVv#!Ubq>(C+Fw1Jo7ar*h5J!u2b7mLxy)~E3PI=o?$M(30)jjlVzi;)}HB%$cM3Y5#s>ZsxnWb7&}K&@RX0)IKmk|L*Lhyv9aj`rwY> z`e~MJ`7moL9S%Q7@Q$d62hsqrewHEx{P6eA{QQJ|2X_hF7IGKDi#T5|FQj97XVn?tH)DZ_RT(W#4ye3oaY7t z^p(wS!t{q@~dh4ySwSs;9yF3_|<~nBlwgZ%(o)|tVd0Tz)su25xd;^b_QT_u_#jz zNC6PB)17a309d>z!)=%w0EpPpe7gfM`Lc-F5LgXBI2wIzufTQ^Par`E%-Cy}03d8< z^PK_!>jx%6U=;x2Xw;GuN}d3~ObDz1AnXM5ody7lck$ANAkzSJJH>n_0$>INnFOFa z8l{h0xu5Sv0MdOhob6r0vJ~I-<8LbYNKuh^Z9D-0i+AwM><-ciHh=250LMr?fi%S@ zeEIu$C8N`+=DPs^X$U%phG>yf&36j`tfkwxTMj{|)6I7i0IVezLU3wu(D~-O4S>nL zd^7j%uVy|UFO$Aj4S)ayr`%*dOFV%L={sAunhrt7;2_=NCiC44fY}gqxY2yK1Hj@l z{KnBVL*^SulJ>&~(=+I{-8(dHGN zI6?0c{72_Zlo15hHK zh!zRepopgcpEdx!2_e8=c?4K0o`@C+)!;s*g24p}Ag)b7uYowGLZO?L5r~a8NJtAU zt-;}O^Tz>rP8)z;1MnYH0l3`;32C8)H3$T5dmR8h4UoqGYl;{ZHqgT%DZk{Ud5 zB>-7j^A*53Z34O-!al?6X#?PC8ziWO8LR=oa&^@R25(e|J=z3xD}-Sc3SF;e48Q+T z8zicQ8K^-Z@Iy6g5Y17D`?Lw@E(ihk8r~)pe*Yo`a9%uVEi$PF{VEt-n3(ymL$FL6 zfbM`0V2Mg80J6oC*P=9QkflJ7JA!^v QO#lD@07*qoM6N<$f=2%)R{#J2 literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-nodpi/tether_circle.png b/app/src/main/res/drawable-nodpi/tether_circle.png new file mode 100644 index 0000000000000000000000000000000000000000..b8558cb76772bc427491dbb648105e83a308b74a GIT binary patch literal 2497 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 LNkvXXu0mjf=QqsT literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-nodpi/tether_coin.png b/app/src/main/res/drawable-nodpi/tether_coin.png new file mode 100644 index 0000000000000000000000000000000000000000..f283be245e77b338aeae3cbc1b9f31b4febe1166 GIT binary patch literal 2257140 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

4fkOCa}*yg z@)mh*f!u`+N5SdnD1UqL*R`a(jVe}QUHPAP(9%07QYbXwS`L#ftEA>t;g-z$P@eWIBX7!e zZ!_Of_+@Fl2n0nKq#uvF8$E(N1zDxuE0SU@IzK7)JH-e~!!^VGW?Nh^Es(GXC)^A> z1LsI!{OiS+Q_XkNF_K zm~$DJh3w|VwIexEO!AqP^$4y;YvNB2P{)?I?mYEPWxWuSA-^g{>BT)2kGDS#Fy4P4 zo2g(`Bo;PGTNkl4tK5G^r(jV3@r2^ zGLfe5ijM^j3+%?tdQvnk{GL-Tg4EZeNl+vYIGRQa1e<~7nc;o}pX8j~?tW85dhel!olcSVvb}6`#g7KmrrI(yLY5T zd2!wKNcU~B&wRM{3}w!XUlCVF=y{gK|mFQE~&JqpY(5c99DYOQ=QNjUA#GT+(q<`@j@hWgotD2D@$L z)&t^eEwM~FzNd+QLt7Hdl*&*8!m`=pV&dX z1@GA#T#1$9$zubKA>-c^FK@>_Be+yae(*eA-W0~|f%k4mcJF|zvex1>S}Fe38VpXf zWmB0GC!>YCk;?_en;p4gPU<@vE=t;b@%j?X@d}KQRxagVyUPQ1COXT$P)N;)DjcxDna?88`IDYw)?vsAO@hBZqSs`R;%6p`#d-PducFMVdgaap;_ci4XJDa+&hx^Dl*Uh;GgX9f7mq#4w=D|^Tk183Z!|G$=2Wv z|HWlpxaBM4MFt-f$F-nYkzn8X7K!N%LI4>50p>Z5N9Ms=v5t5Z3i%c^jo#_?WT#mu zWiq%qV#RDYCk|`wrG<@{-a_n6keuTiR?jq&-x#Di*4!Pr+|VGCH6zIHfP9SD;7;5; z7+Hr~ZsVk!JYaErXA_%q%2f|xuAd^-uYd(c;Ld#!Uw;pW6Y)|P1crVb2%(xFG5|S^ zxyIwzCP*&MSQH8JcG!t3kIT)oQqh}KG9S_?GGwg8YcB ze+KWuS~1kKDiciNYDBW`7JPyh{iSGSvG-=WxgB2*t-^{D($*5Z*jZK=7Fmk3hVipTj-&`pjOsDJhJ~Qy7xKpp zS*E1;3QcN=tIyLik61!#31%sc9K>B~XzM9NT38od206v$V-SdO3#tCiiK<4ndIj%! z7L-gcfgK_;mslk?Qd}9}pfI7==urkDby`Y+m&Ce9;ZNz@SZp+$_kcfRi=8C9;ZUXC=9@_ak!p(EOCCQ$bK$}t@xUR9ofmUI z8if-;7F*()Lhz`#xK%{5qJ_z05}H5(pC;Ye@Rsy32xI?`2Sm@PL@Hjm)`XZfTb!nogG0f>UrRVE~HS{Oux4o)Yo% z!g#W2G)cIRa(;=G;oF5$8!_il@>q+pJEf&vFg8E(Dif`M1MeoIpDZX6EpC-R5n{

vJ?l_!qS^# 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ⅅZE*XcKw{cXbsR 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ℑQ&4`nbLlOc~e2@H&9BtmB}V?(>u`2 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�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 z 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⁣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�rr=>{*VO6G5}fRIj~BwA)c7a$##qMr>8ik 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

D;!mt%*uBEXh7-SE3Awz5 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 z%0D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Ό=3E$NWus@w^7ED9f^UF#AMh4~Cw;^( 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

~kysyP;dVt}Nl?kNJyNU71}=-_ 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 z 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

bT9s>W}FNwHDLW_9MLfYXD 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