core, ui: badge redeem errors and fixes (#7515)

- redeem errors are typed (CEBadgeRedeemError) instead of matched by text in the apps
- service timeout (A_SERVICE) decodes in the apps and offers Retry via the existing retry alert
- unexpected redeem errors show the error itself instead of a generic message
- service error codes are a typed enum in the apps (BadgeServiceErrorCode)
- CRBadgeRedeemed returns badge state, so the apps skip a second round-trip after redeem
- setBadgeAlertAcked is scoped to user_id
- badgeChanged updates non-active profiles, so other profiles' badges don't go stale
- pitch banner is not shown to a profile that already has a badge
- one badgeTypeName per platform, used by the badge screen and the badge info alert
- BadgeAlertKind and BadgeAlertPrice decode via standard JSON, no custom decoders
- dead "Support ended" title branch removed from Your Badge view
- kotlin: users from badge responses carry remoteHostId
- kotlin: redeem code field keeps the IME's cursor and composition state
- kotlin: "Get your code" shown in all flavours
- kotlin: "Don't show again" -> "Dismiss", matching iOS
- kotlin: parseBadgeCode moved next to its FFI in platform/Core.kt
- kotlin: BadgesView no longer cross-fades on badge state updates
- kotlin: section title not uppercased
- ios: redeem code field parses once per change
- ios: A_SERVICE rejected reason is not decoded
- CLI: "cannot redeem badge code: ..." with the source of the error
- comments clarified
This commit is contained in:
spaced4ndy authored and GitHub committed 2026-09-16 14:15:11 +00:00
1 parent 9af6fb00e6
commit f38c7e0f2b
26 files changed
+482 -434

No files matched your search

+14 -3
View File
@@ -420,7 +420,7 @@ enum ChatCommand: ChatCmdProtocol {
case let .apiRedeemBadgeCode(userId, code): return "/_redeem_badge_code \(userId) \(code)"
case let .apiGetBadgeState(userId): return "/_badge state \(userId)"
case let .apiAckBadgeAlert(userId, badgePurchaseId, alertKind, snooze, episode):
return "/_badge ack \(userId) \(badgePurchaseId) \(alertKind.text) \(onOff(snooze)) \(episode)"
return "/_badge ack \(userId) \(badgePurchaseId) \(badgeAlertKindParam(alertKind)) \(onOff(snooze)) \(episode)"
case .showVersion: return "/version"
case let .getAgentSubsTotal(userId): return "/get subs total \(userId)"
case let .getAgentServersSummary(userId): return "/get servers summary \(userId)"
@@ -693,6 +693,17 @@ enum ChatCommand: ChatCmdProtocol {
pwd == "" || pwd == nil ? "" : " " + encodeJSON(pwd)
}
// /_badge ack takes the kind in core's text encoding, not the JSON tag
private func badgeAlertKindParam(_ kind: BadgeAlertKind) -> String {
switch kind {
case .renewalApproaching: "renewal_approaching"
case .paymentIssue: "payment_issue"
case .subscriptionEnded: "subscription_ended"
case .prepaidEnding: "prepaid_ending"
case .supportEnded: "support_ended"
}
}
private func maybeContent(_ mc: MsgContent?) -> String {
if case let .text(s) = mc, s.isEmpty {
""
@@ -1035,7 +1046,7 @@ enum ChatResponse2: Decodable, ChatAPIResult {
case appSettings(appSettings: AppSettings)
// badges
// the full user, not UserRef: its profile carries the badge that setUserBadge just stored
case badgeRedeemed(user: User, redeemedBadge: LocalBadge, newBadge: Bool)
case badgeRedeemed(user: User, redeemedBadge: LocalBadge, newBadge: Bool, badgeState: BadgeState?)
case badgeState(user: UserRef, badgeState: BadgeState?)
var responseType: String {
@@ -1143,7 +1154,7 @@ enum ChatResponse2: Decodable, ChatAPIResult {
case let .archiveExported(archiveErrors): return String(describing: archiveErrors)
case let .archiveImported(archiveErrors): return String(describing: archiveErrors)
case let .appSettings(appSettings): return String(describing: appSettings)
case let .badgeRedeemed(u, redeemedBadge, newBadge): return withUser(u, "redeemedBadge: \(String(describing: redeemedBadge))\nnewBadge: \(newBadge)")
case let .badgeRedeemed(u, redeemedBadge, newBadge, badgeState): return withUser(u, "redeemedBadge: \(String(describing: redeemedBadge))\nnewBadge: \(newBadge)\nbadgeState: \(String(describing: badgeState))")
case let .badgeState(u, badgeState): return withUser(u, String(describing: badgeState))
}
}
+37 -84
View File
@@ -124,8 +124,8 @@ func chatSendCmd<R: ChatAPIResult>(_ cmd: ChatCommand, bgTask: Bool = true, bgDe
}
// Spec: spec/api.md#chatApiSendCmdWithRetry
func chatApiSendCmdWithRetry<R: ChatAPIResult>(_ cmd: ChatCommand, bgTask: Bool = true, bgDelay: Double? = nil, inProgress: BoxedValue<Bool>? = nil, retryNum: Int32 = 0) async -> APIResult<R>? {
let r: APIResult<R> = await chatApiSendCmd(cmd, bgTask: bgTask, bgDelay: bgDelay, retryNum: retryNum)
func chatApiSendCmdWithRetry<R: ChatAPIResult>(_ cmd: ChatCommand, bgTask: Bool = true, bgDelay: Double? = nil, inProgress: BoxedValue<Bool>? = nil, retryNum: Int32 = 0, log: Bool = true) async -> APIResult<R>? {
let r: APIResult<R> = await chatApiSendCmd(cmd, bgTask: bgTask, bgDelay: bgDelay, retryNum: retryNum, log: log)
if inProgress == nil || inProgress?.boxedValue == true,
case let .error(e) = r, let alert = retryableNetworkErrorAlert(e) {
return await withCheckedContinuation { cont in
@@ -135,7 +135,7 @@ func chatApiSendCmdWithRetry<R: ChatAPIResult>(_ cmd: ChatCommand, bgTask: Bool
cont.resume(returning: nil)
},
onRetry: {
let r1: APIResult<R>? = await chatApiSendCmdWithRetry(cmd, bgTask: bgTask, bgDelay: bgDelay, inProgress: inProgress, retryNum: retryNum + 1)
let r1: APIResult<R>? = await chatApiSendCmdWithRetry(cmd, bgTask: bgTask, bgDelay: bgDelay, inProgress: inProgress, retryNum: retryNum + 1, log: log)
cont.resume(returning: r1)
}
)
@@ -200,6 +200,10 @@ func retryableNetworkErrorAlert(_ e: ChatError) -> (title: String, message: Stri
title: NSLocalizedString("No private routing session", comment: "alert title"),
message: proxyDestinationErrorAlertMessage(proxyServer: proxyServer, destServer: destServer)
)
case .errorAgent(.AGENT(.A_SERVICE(.timeout))): (
title: NSLocalizedString("Connection timeout", comment: "alert title"),
message: NSLocalizedString("The service did not respond. Please try again.", comment: "alert message")
)
default: nil
}
}
@@ -2182,86 +2186,35 @@ func resetAgentServersStats() async throws {
try await sendCommandOkResp(.resetAgentServersStats)
}
// The failures redeemBadgeCode raises, as core flattens them to command error text.
// tests/Bots/BadgeServiceTests.hs asserts that text, so a change in core breaks a test there.
enum BadgeRedeemError: Error {
case invalidCode
case serviceNotConfigured
case alreadyActive
case codeInvalid
case codeUsed
case codeExpired
case rateLimited
case serviceFailed
case badServiceResponse
case credentialNotVerified
case unsupportedVersion
case networkError
case badgeEnded
case unknown
// log: false because the code is a bearer secret until it is redeemed - it is in the command.
// nil when the user cancels the retry alert.
func apiRedeemBadgeCode(_ userId: Int64, _ code: String) async throws -> (user: User, newBadge: Bool, badgeState: BadgeState?)? {
let r: APIResult<ChatResponse2>? = await chatApiSendCmdWithRetry(.apiRedeemBadgeCode(userId: userId, code: code), log: false)
guard let r else { return nil }
// redeemedBadge is dropped: the user's profile carries what is shown
if case let .result(.badgeRedeemed(user, _, newBadge, badgeState)) = r { return (user, newBadge, badgeState) }
throw r.unexpected
}
private enum BadgeErrorText {
static let invalidCode = "invalid badge code"
static let serviceNotConfigured = "badge service not configured"
static let alreadyActive = "badge already active"
static let unknownKeyIndex = "unknown badge key index"
static let credentialNotVerified = "badge credential does not verify against configured key"
static let invalidResponse = "invalid badge service response, "
static let unexpectedResponse = "unexpected badge service response: "
static let serviceError = "badge service error: "
// raised by sendServiceRequestTo, not by redeemBadgeCode itself, when the reply is not JSON
static let undecodableResponse = "invalid service response"
}
func badgeRedeemError(_ error: ChatError) -> BadgeRedeemError {
// the app's own classifier decides what counts as a network failure; only the classification is
// used here, not its retry policy - a client that retries makes code guessing cheaper
if retryableNetworkErrorAlert(error) != nil { return .networkError }
guard case let .error(.commandError(message)) = error else { return .unknown }
switch message {
case BadgeErrorText.invalidCode: return .invalidCode
case BadgeErrorText.serviceNotConfigured: return .serviceNotConfigured
case BadgeErrorText.alreadyActive: return .alreadyActive
case BadgeErrorText.unknownKeyIndex, BadgeErrorText.credentialNotVerified: return .credentialNotVerified
case BadgeErrorText.undecodableResponse: return .badServiceResponse
default: break
}
if message.hasPrefix(BadgeErrorText.invalidResponse) || message.hasPrefix(BadgeErrorText.unexpectedResponse) {
return .badServiceResponse
}
if message.hasPrefix(BadgeErrorText.serviceError) {
return badgeServiceError(String(message.dropFirst(BadgeErrorText.serviceError.count)))
}
return .unknown
}
// the service's own tag, which core bounds to [a-z0-9_] and 32 characters and which is never shown
private func badgeServiceError(_ tag: String) -> BadgeRedeemError {
switch tag {
case "code_invalid": return .codeInvalid
case "code_used": return .codeUsed
case "code_expired": return .codeExpired
case "rate_limited": return .rateLimited
// retrying never succeeds: the client is too old for the service
case "unsupported_version": return .unsupportedVersion
default: return .serviceFailed
}
}
// log: false because the code is a bearer secret until it is redeemed - it is in the command, and a
// service response echoed into an error message would carry it into the terminal with the response.
func apiRedeemBadgeCode(_ userId: Int64, _ code: String) async throws -> (user: User, newBadge: Bool) {
let r: APIResult<ChatResponse2> = await chatApiSendCmd(.apiRedeemBadgeCode(userId: userId, code: code), log: false)
switch r {
// redeemedBadge is dropped: it is the credential, and the user's profile carries what is shown
case let .result(.badgeRedeemed(user, _, newBadge)): return (user, newBadge)
case let .error(e): throw badgeRedeemError(e)
default:
// the response type alone - it names a case or a JSON key, never the service's message
logger.error("apiRedeemBadgeCode: unexpected \(r.responseType)")
throw BadgeRedeemError.unknown
// localized where the user can act on it; otherwise the error itself, so a screenshot says what happened
func redeemErrorText(_ error: Error) -> String {
if case let .error(.badgeRedeemError(e)) = error as? ChatError {
switch e {
case .invalidCode: return NSLocalizedString("This code is not valid.", comment: "alert message")
case .serviceNotConfigured: return NSLocalizedString("This app version cannot redeem badge codes.", comment: "alert message")
case .badgeActive: return NSLocalizedString("This profile already has a badge. Redeem the code on another profile, or once this badge ends.", comment: "alert message")
case .serviceError(.codeInvalid): return NSLocalizedString("This code was not recognised.", comment: "alert message")
case .serviceError(.codeUsed): return NSLocalizedString("This code has already been used.", comment: "alert message")
case .serviceError(.codeExpired): return NSLocalizedString("This code has expired.", comment: "alert message")
case .serviceError(.rateLimited): return NSLocalizedString("Too many attempts. Please try again later.", comment: "alert message")
case .serviceError(.unsupportedVersion): return NSLocalizedString("This app version is too old for the badge service. Please update the app.", comment: "alert message")
case .serviceError: break
case let .invalidResponse(message):
return String.localizedStringWithFormat(NSLocalizedString("The badge service sent an unexpected response: %@", comment: "alert message"), message)
case .unknownKeyIndex, .credentialNotVerified: return NSLocalizedString("This app version cannot verify this badge. Please update the app.", comment: "alert message")
}
}
return String.localizedStringWithFormat(NSLocalizedString("Error: %@", comment: "alert message"), responseError(error))
}
func apiGetBadgeState(_ userId: Int64) async throws -> BadgeState? {
@@ -3085,10 +3038,10 @@ func processReceivedMsg(_ res: ChatEvent) async {
}
}
case let .badgeChanged(user, badgeState):
if active(user) {
await MainActor.run {
// read by core after retiring or presenting, so it carries the profile badge as changed
m.updateUser(user)
await MainActor.run {
// read by core after retiring or presenting, so it carries the profile badge as changed
m.updateUser(user)
if active(user) {
BadgeModel.shared.set(userId: user.userId, badgeState: badgeState)
}
}
@@ -123,24 +123,30 @@ struct BadgesRedeemCodeView: View {
.disabled(submitting)
}
// a changed field re-enters through onChange with the formatted text, which is when it is parsed
private func applyCodeInput(_ s: String) {
let formatted = formatBadgeCodeInput(s)
if formatted != code { code = formatted }
canonicalCode = parseBadgeCode(formatted)
if formatted != code {
code = formatted
} else {
canonicalCode = parseBadgeCode(formatted)
}
}
private func processQRCode(_ resp: Result<ScanResult, ScanError>) {
switch resp {
case let .success(r):
let formatted = formatBadgeCodeInput(r.string)
if parseBadgeCode(formatted) == nil {
if let canonical = parseBadgeCode(formatted) {
// set here rather than through onChange, which runs after redeem() reads it
code = formatted
canonicalCode = canonical
redeem()
} else {
showAlert(
NSLocalizedString("Invalid QR code", comment: "alert title"),
message: NSLocalizedString("The code you scanned is not a badge code.", comment: "alert message")
)
} else {
applyCodeInput(formatted)
redeem()
}
case let .failure(e):
logger.error("processQRCode QR code error: \(e.localizedDescription)")
@@ -167,56 +173,36 @@ struct BadgesRedeemCodeView: View {
submitting = true
Task {
do {
let (redeemedUser, newBadge) = try await apiRedeemBadgeCode(user.userId, sending)
let badgeState = try? await apiGetBadgeState(user.userId)
guard let redeemed = try await apiRedeemBadgeCode(user.userId, sending) else {
await MainActor.run { submitting = false }
return
}
await MainActor.run {
submitting = false
// written before the pop: BadgesView swaps its content under this pushed view, so
// the pop reveals Your Badge already in place rather than animating it afterwards
if let badgeState {
BadgeModel.shared.set(userId: user.userId, badgeState: badgeState)
}
// the response is the only carrier: redeeming raises no event that refreshes the
// profile, so without this the badge beside the name is the one from before
chatModel.updateUser(redeemedUser)
if let badgeState, !badgeState.shown {
// set before dismissing: BadgesView then switches Support to Your Badge while this screen
// still covers it, so the pop lands on Your Badge instead of showing the switch
BadgeModel.shared.set(userId: user.userId, badgeState: redeemed.badgeState)
chatModel.updateUser(redeemed.user)
if let badgeState = redeemed.badgeState, !badgeState.shown {
// a replay adds no purchase; a fresh code's badge can be retired on arrival
showAlert(NSLocalizedString("Cannot redeem code", comment: "alert title"), message: failureMessage(newBadge ? .badgeEnded : .codeUsed))
let message = redeemed.newBadge
? NSLocalizedString("The code was accepted, but the badge it grants has already ended.", comment: "alert message")
: NSLocalizedString("This code has already been used.", comment: "alert message")
showAlert(NSLocalizedString("Cannot redeem code", comment: "alert title"), message: message)
} else {
supporterBannerShown = true
dismiss()
}
}
} catch let error {
let redeemError = error as? BadgeRedeemError ?? .unknown
// the mapped case only - core embeds the service's response in some of these messages
logger.error("apiRedeemBadgeCode: \(String(describing: redeemError))")
logger.error("apiRedeemBadgeCode: \(responseError(error))")
await MainActor.run {
submitting = false
showAlert(NSLocalizedString("Cannot redeem code", comment: "alert title"), message: failureMessage(redeemError))
showAlert(NSLocalizedString("Cannot redeem code", comment: "alert title"), message: redeemErrorText(error))
}
}
}
}
private func failureMessage(_ failure: BadgeRedeemError) -> String {
switch failure {
case .invalidCode: NSLocalizedString("This code is not valid.", comment: "alert message")
case .serviceNotConfigured: NSLocalizedString("This app version cannot redeem badge codes.", comment: "alert message")
case .alreadyActive: NSLocalizedString("This profile already has a badge. Redeem the code on another profile, or once this badge ends.", comment: "alert message")
case .codeInvalid: NSLocalizedString("This code was not recognised.", comment: "alert message")
case .codeUsed: NSLocalizedString("This code has already been used.", comment: "alert message")
case .codeExpired: NSLocalizedString("This code has expired.", comment: "alert message")
case .rateLimited: NSLocalizedString("Too many attempts. Please try again later.", comment: "alert message")
case .serviceFailed: NSLocalizedString("The badge service is unavailable. Please try again later.", comment: "alert message")
case .badServiceResponse: NSLocalizedString("The badge service sent an unexpected response.", comment: "alert message")
case .credentialNotVerified: NSLocalizedString("This app version cannot verify this badge. Please update the app.", comment: "alert message")
case .unsupportedVersion: NSLocalizedString("This app version is too old for the badge service. Please update the app.", comment: "alert message")
case .networkError: NSLocalizedString("Connection error. Please check your network connection.", comment: "alert message")
case .badgeEnded: NSLocalizedString("The code was accepted, but the badge it grants has already ended.", comment: "alert message")
case .unknown: NSLocalizedString("The code could not be redeemed.", comment: "alert message")
}
}
}
struct BadgesRedeemCodeView_Previews: PreviewProvider {
@@ -14,18 +14,10 @@ struct BadgesYourBadgeView: View {
let badgeState: BadgeState
var showsAsSheet: Bool = false
private var title: LocalizedStringKey {
badgeState.shown ? "Your badge" : "Support ended"
}
// pushed, the navigation bar carries the title and animates it; as a sheet root there is no bar
// to put it in, so the title is drawn in the content, as the Support screen does
private var navTitle: LocalizedStringKey { showsAsSheet ? "" : title }
var body: some View {
VStack(spacing: 0) {
if showsAsSheet {
Text(title)
Text("Your badge")
.font(.largeTitle)
.bold()
.foregroundColor(theme.colors.primary)
@@ -51,7 +43,7 @@ struct BadgesYourBadgeView: View {
}
}
.frame(maxHeight: .infinity)
.navigationTitle(navTitle)
.navigationTitle(showsAsSheet ? "" : "Your badge")
.navigationBarTitleDisplayMode(showsAsSheet ? .inline : .large)
.modifier(ThemedBackground(grouped: true))
}
@@ -69,7 +61,7 @@ struct BadgeSummary: View {
.frame(width: 68, height: 68)
.padding(.bottom, 8)
badgeTypeName(badgeState.badgeType)
Text(badgeTypeName(badgeState.badgeType))
.font(.title3)
.fontWeight(.semibold)
@@ -81,13 +73,3 @@ struct BadgeSummary: View {
.padding(.vertical, 8)
}
}
// verbatim for an unknown type: it is the service's string, and must not be looked up as a localised key
private func badgeTypeName(_ t: BadgeType) -> Text {
switch t {
case .supporter: Text("Supporter")
case .legend: Text("Legend")
case .investor: Text("Investor")
case let .unknown(s): Text(verbatim: s)
}
}
@@ -382,6 +382,10 @@ struct ChatListView: View {
badgeModel.alert?.kind == .supportEnded && badgeModel.userId == chatModel.currentUser?.userId
}
private var hasShownBadge: Bool {
badgeModel.badgeState?.shown == true && badgeModel.userId == chatModel.currentUser?.userId
}
private func showSupportEndedDismissAlert() {
showAlert(NSLocalizedString("Support ended", comment: "alert title")) {
[
@@ -470,7 +474,7 @@ struct ChatListView: View {
.listRowSeparator(.hidden)
.listRowBackground(Color.clear)
.zIndex(1)
} else if !supporterBannerShown && chatModel.chats.count > 3 {
} else if !supporterBannerShown && !hasShownBadge && chatModel.chats.count > 3 {
SupportSimpleXBanner(
onTap: { showBadgesSheet = true },
onDismiss: showSupportSimpleXDismissAlert
+11 -2
View File
@@ -147,8 +147,7 @@ func showBadgeInfoAlert(_ name: String, _ badge: LocalBadge) {
)
default:
// a verified badge's type is signed and can't be faked, so the real (possibly unknown) type name is the title
let t = badge.badge.badgeType.text
let title = t.prefix(1).uppercased() + t.dropFirst()
let title = badgeTypeName(badge.badge.badgeType)
if case .investor = badge.badge.badgeType {
let message = String.localizedStringWithFormat(NSLocalizedString("%@ invested in SimpleX Chat crowdfunding.", comment: "badge alert"), name)
showAlert(title, message: message) {
@@ -172,3 +171,13 @@ func showBadgeInfoAlert(_ name: String, _ badge: LocalBadge) {
}
}
}
// verbatim for an unknown type: it is the service's string, and must not be looked up as a localised key
func badgeTypeName(_ t: BadgeType) -> String {
switch t {
case .supporter: NSLocalizedString("Supporter", comment: "badge type")
case .legend: NSLocalizedString("Legend", comment: "badge type")
case .investor: NSLocalizedString("Investor", comment: "badge type")
case let .unknown(s): s
}
}
+2 -2
View File
@@ -163,8 +163,8 @@ public func chatJsonLength(_ s: String) -> Int {
return Int(chat_json_length(&c))
}
// The code as core will accept it - prefix and 20 characters, no separators - or nil if it does not
// parse. Validity is decided only here: a second check-character implementation would drift.
// the code in core's canonical form (prefix and 20 characters, no separators), or nil when core rejects it.
// The check character is verified by core via FFI, not re-implemented here, so the two cannot disagree.
public func parseBadgeCode(_ s: String) -> String? {
var c = s.cString(using: .utf8)!
let canonical = fromCString(chat_parse_badge_code(&c)!)
+88
View File
@@ -812,6 +812,7 @@ public enum ChatErrorType: Decodable, Hashable {
case agentVersion
case agentNoSubResult(agentConnId: String)
case commandError(message: String)
case badgeRedeemError(badgeRedeemError: BadgeRedeemError)
case serverProtocol
case agentCommandError(message: String)
case invalidFileDescription(message: String)
@@ -823,6 +824,84 @@ public enum ChatErrorType: Decodable, Hashable {
case exception(message: String)
}
public enum BadgeRedeemError: Decodable, Hashable {
case invalidCode
case serviceNotConfigured
case badgeActive
case serviceError(serviceError: BadgeServiceErrorCode)
case invalidResponse(message: String)
case unknownKeyIndex
case credentialNotVerified
}
// the service is deployed ahead of clients, so a code this version does not know keeps its tag
public enum BadgeServiceErrorCode: Decodable, Hashable {
case badRequest
case unsupportedVersion
case unknownPurchaseKey
case unknownOfferId
case offerDisabled
case offerMismatch
case productUnavailable
case paymentNotEntitled
case paymentPending
case providerUnavailable
case rateLimited
case codeInvalid
case codeUsed
case codeExpired
case receiptInvalid
case receiptUsed
case internalError
case unknown(String)
public var text: String {
switch self {
case .badRequest: "bad_request"
case .unsupportedVersion: "unsupported_version"
case .unknownPurchaseKey: "unknown_purchase_key"
case .unknownOfferId: "unknown_offer_id"
case .offerDisabled: "offer_disabled"
case .offerMismatch: "offer_mismatch"
case .productUnavailable: "product_unavailable"
case .paymentNotEntitled: "payment_not_entitled"
case .paymentPending: "payment_pending"
case .providerUnavailable: "provider_unavailable"
case .rateLimited: "rate_limited"
case .codeInvalid: "code_invalid"
case .codeUsed: "code_used"
case .codeExpired: "code_expired"
case .receiptInvalid: "receipt_invalid"
case .receiptUsed: "receipt_used"
case .internalError: "internal"
case let .unknown(s): s
}
}
public init(from decoder: Decoder) throws {
switch try decoder.singleValueContainer().decode(String.self) {
case "bad_request": self = .badRequest
case "unsupported_version": self = .unsupportedVersion
case "unknown_purchase_key": self = .unknownPurchaseKey
case "unknown_offer_id": self = .unknownOfferId
case "offer_disabled": self = .offerDisabled
case "offer_mismatch": self = .offerMismatch
case "product_unavailable": self = .productUnavailable
case "payment_not_entitled": self = .paymentNotEntitled
case "payment_pending": self = .paymentPending
case "provider_unavailable": self = .providerUnavailable
case "rate_limited": self = .rateLimited
case "code_invalid": self = .codeInvalid
case "code_used": self = .codeUsed
case "code_expired": self = .codeExpired
case "receipt_invalid": self = .receiptInvalid
case "receipt_used": self = .receiptUsed
case "internal": self = .internalError
case let s: self = .unknown(s)
}
}
}
public enum StoreError: Decodable, Hashable {
case duplicateName
case userNotFound(userId: Int64)
@@ -1077,6 +1156,15 @@ public enum SMPAgentError: Decodable, Hashable {
case A_CRYPTO
case A_DUPLICATE
case A_QUEUE(queueErr: String)
case A_SERVICE(serviceError: AgentServiceError)
}
public enum AgentServiceError: Decodable, Hashable {
case rejected
case timeout
case noPendingRequest
case notDRAddress
case badSignature
}
public enum ArchiveError: Decodable, Hashable {
+2 -47
View File
@@ -350,62 +350,17 @@ private func badgeDateText(_ date: Date) -> String {
DateFormatter.localizedString(from: date, dateStyle: .long, timeStyle: .none)
}
public struct BadgeAlertPrice: Hashable {
public struct BadgeAlertPrice: Codable, Hashable {
public var amount: Int64
public var currency: String
}
extension BadgeAlertPrice: Codable {
// encoded as the Haskell tuple it comes from: [amount, currency]
public init(from decoder: Decoder) throws {
var c = try decoder.unkeyedContainer()
amount = try c.decode(Int64.self)
currency = try c.decode(String.self)
}
public func encode(to encoder: Encoder) throws {
var c = encoder.unkeyedContainer()
try c.encode(amount)
try c.encode(currency)
}
}
public enum BadgeAlertKind: Hashable {
public enum BadgeAlertKind: String, Codable, Hashable {
case renewalApproaching
case paymentIssue
case subscriptionEnded
case prepaidEnding
case supportEnded
case unknown(String)
public var text: String {
switch self {
case .renewalApproaching: "renewal_approaching"
case .paymentIssue: "payment_issue"
case .subscriptionEnded: "subscription_ended"
case .prepaidEnding: "prepaid_ending"
case .supportEnded: "support_ended"
case let .unknown(s): s
}
}
}
extension BadgeAlertKind: Codable {
public init(from decoder: Decoder) throws {
switch try decoder.singleValueContainer().decode(String.self) {
case "renewal_approaching": self = .renewalApproaching
case "payment_issue": self = .paymentIssue
case "subscription_ended": self = .subscriptionEnded
case "prepaid_ending": self = .prepaidEnding
case "support_ended": self = .supportEnded
case let s: self = .unknown(s)
}
}
public func encode(to encoder: Encoder) throws {
var c = encoder.singleValueContainer()
try c.encode(text)
}
}
// the wire proof carried on a profile - opaque to the UI, only round-tripped back to the core (apiPrepareContact)
+2 -1
View File
@@ -534,7 +534,8 @@ func chatApiSendCmdWithRetry<R: ChatAPIResult>( // SimpleXAPI.swift L127
bgTask: Bool = true,
bgDelay: Double? = nil,
inProgress: BoxedValue<Bool>? = nil,
retryNum: Int32 = 0
retryNum: Int32 = 0,
log: Bool = true
) async -> APIResult<R>?
```
@@ -2246,55 +2246,16 @@ data class BadgeAlert(
val dateText: String get() = badgeDateText(date)
}
@Serializable(with = BadgeAlertPriceSerializer::class)
@Serializable
data class BadgeAlertPrice(val amount: Long, val currency: String)
// encoded as the Haskell tuple it comes from: [amount, currency]
object BadgeAlertPriceSerializer : KSerializer<BadgeAlertPrice> {
override val descriptor: SerialDescriptor = buildClassSerialDescriptor("BadgeAlertPrice")
override fun deserialize(decoder: Decoder): BadgeAlertPrice {
require(decoder is JsonDecoder)
val arr = decoder.decodeJsonElement().jsonArray
return BadgeAlertPrice(arr[0].jsonPrimitive.long, arr[1].jsonPrimitive.content)
}
override fun serialize(encoder: Encoder, value: BadgeAlertPrice) {
require(encoder is JsonEncoder)
encoder.encodeJsonElement(buildJsonArray { add(value.amount); add(value.currency) })
}
}
@Serializable(with = BadgeAlertKindSerializer::class)
sealed class BadgeAlertKind {
@Serializable @SerialName("renewal_approaching") object RenewalApproaching: BadgeAlertKind()
@Serializable @SerialName("payment_issue") object PaymentIssue: BadgeAlertKind()
@Serializable @SerialName("subscription_ended") object SubscriptionEnded: BadgeAlertKind()
@Serializable @SerialName("prepaid_ending") object PrepaidEnding: BadgeAlertKind()
@Serializable @SerialName("support_ended") object SupportEnded: BadgeAlertKind()
@Serializable @SerialName("unknown") data class Unknown(val kind: String): BadgeAlertKind()
val text: String
get() = when (this) {
is RenewalApproaching -> "renewal_approaching"
is PaymentIssue -> "payment_issue"
is SubscriptionEnded -> "subscription_ended"
is PrepaidEnding -> "prepaid_ending"
is SupportEnded -> "support_ended"
is Unknown -> kind
}
}
object BadgeAlertKindSerializer : KSerializer<BadgeAlertKind> {
override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("BadgeAlertKind", PrimitiveKind.STRING)
override fun deserialize(decoder: Decoder): BadgeAlertKind =
when (val v = decoder.decodeString()) {
"renewal_approaching" -> BadgeAlertKind.RenewalApproaching
"payment_issue" -> BadgeAlertKind.PaymentIssue
"subscription_ended" -> BadgeAlertKind.SubscriptionEnded
"prepaid_ending" -> BadgeAlertKind.PrepaidEnding
"support_ended" -> BadgeAlertKind.SupportEnded
else -> BadgeAlertKind.Unknown(v)
}
override fun serialize(encoder: Encoder, value: BadgeAlertKind) = encoder.encodeString(value.text)
@Serializable
enum class BadgeAlertKind {
@SerialName("renewalApproaching") RenewalApproaching,
@SerialName("paymentIssue") PaymentIssue,
@SerialName("subscriptionEnded") SubscriptionEnded,
@SerialName("prepaidEnding") PrepaidEnding,
@SerialName("supportEnded") SupportEnded
}
private fun badgeDateText(date: Instant): String {
@@ -562,55 +562,44 @@ object ChatController {
suspend fun resetAgentServersStats(rh: Long?): Boolean = sendCommandOkResp(rh, CC.ResetAgentServersStats())
fun badgeRedeemError(error: ChatError): BadgeRedeemError {
// the app's own classifier decides what counts as a network failure; only the classification is
// used here, not its retry policy - a client that retries makes code guessing cheaper
if (retryableNetworkErrorAlert(error) != null) return BadgeRedeemError.NetworkError
if (error !is ChatError.ChatErrorChat || error.errorType !is ChatErrorType.CommandError) return BadgeRedeemError.Unknown
val message = error.errorType.message
when (message) {
BadgeErrorText.invalidCode -> return BadgeRedeemError.InvalidCode
BadgeErrorText.serviceNotConfigured -> return BadgeRedeemError.ServiceNotConfigured
BadgeErrorText.alreadyActive -> return BadgeRedeemError.AlreadyActive
BadgeErrorText.unknownKeyIndex, BadgeErrorText.credentialNotVerified -> return BadgeRedeemError.CredentialNotVerified
BadgeErrorText.undecodableResponse -> return BadgeRedeemError.BadServiceResponse
}
if (message.startsWith(BadgeErrorText.invalidResponse) || message.startsWith(BadgeErrorText.unexpectedResponse)) {
return BadgeRedeemError.BadServiceResponse
}
if (message.startsWith(BadgeErrorText.serviceError)) {
return badgeServiceError(message.removePrefix(BadgeErrorText.serviceError))
}
return BadgeRedeemError.Unknown
}
// the service's own tag, which core bounds to [a-z0-9_] and 32 characters and which is never shown
private fun badgeServiceError(tag: String): BadgeRedeemError = when (tag) {
"code_invalid" -> BadgeRedeemError.CodeInvalid
"code_used" -> BadgeRedeemError.CodeUsed
"code_expired" -> BadgeRedeemError.CodeExpired
"rate_limited" -> BadgeRedeemError.RateLimited
// retrying never succeeds: the client is too old for the service
"unsupported_version" -> BadgeRedeemError.UnsupportedVersion
else -> BadgeRedeemError.ServiceFailed
}
// log = false because the code is a bearer secret until it is redeemed - it is in the command, and a
// service response echoed into an error message would carry it into the terminal with the response.
suspend fun apiRedeemBadgeCode(rh: Long?, userId: Long, code: String): BadgeRedeemResult {
val r = sendCmd(rh, CC.ApiRedeemBadgeCode(userId, code), log = false)
// log = false because the code is a bearer secret until it is redeemed - it is in the command.
// null when the user cancels the retry alert.
suspend fun apiRedeemBadgeCode(rh: Long?, userId: Long, code: String): BadgeRedeemResult? {
val r = sendCmdWithRetry(rh, CC.ApiRedeemBadgeCode(userId, code), log = false) ?: return null
return when {
// redeemedBadge is dropped: it is the credential, and the user's profile carries what is shown
r is API.Result && r.res is CR.BadgeRedeemed -> BadgeRedeemResult.Redeemed(r.res.user, r.res.newBadge)
r is API.Error -> BadgeRedeemResult.Failed(badgeRedeemError(r.err))
// redeemedBadge is dropped: the user's profile carries what is shown
r is API.Result && r.res is CR.BadgeRedeemed -> BadgeRedeemResult.Redeemed(r.res.user.updateRemoteHostId(rh), r.res.newBadge, r.res.badgeState)
r is API.Error -> BadgeRedeemResult.Failed(r.err)
else -> {
// the response type alone - it names a case or a JSON key, never the service's message
Log.e(TAG, "apiRedeemBadgeCode: unexpected ${r.responseType}")
BadgeRedeemResult.Failed(BadgeRedeemError.Unknown)
BadgeRedeemResult.Failed(null)
}
}
}
// localized where the user can act on it; otherwise the error itself, so a screenshot says what happened
fun redeemErrorText(err: ChatError?): String {
if (err is ChatError.ChatErrorChat && err.errorType is ChatErrorType.CEBadgeRedeemError) {
when (val e = err.errorType.badgeRedeemError) {
is BadgeRedeemError.InvalidCode -> return generalGetString(MR.strings.badges_error_invalid_code)
is BadgeRedeemError.ServiceNotConfigured -> return generalGetString(MR.strings.badges_error_service_not_configured)
is BadgeRedeemError.BadgeActive -> return generalGetString(MR.strings.badges_error_already_active)
is BadgeRedeemError.ServiceError -> when (e.serviceError) {
is BadgeServiceErrorCode.CodeInvalid -> return generalGetString(MR.strings.badges_error_code_invalid)
is BadgeServiceErrorCode.CodeUsed -> return generalGetString(MR.strings.badges_error_code_used)
is BadgeServiceErrorCode.CodeExpired -> return generalGetString(MR.strings.badges_error_code_expired)
is BadgeServiceErrorCode.RateLimited -> return generalGetString(MR.strings.badges_error_rate_limited)
is BadgeServiceErrorCode.UnsupportedVersion -> return generalGetString(MR.strings.badges_error_unsupported_version)
else -> {}
}
is BadgeRedeemError.InvalidResponse -> return String.format(generalGetString(MR.strings.badges_error_bad_service_response), e.message)
is BadgeRedeemError.UnknownKeyIndex, is BadgeRedeemError.CredentialNotVerified -> return generalGetString(MR.strings.badges_error_credential_not_verified)
}
}
return "${generalGetString(MR.strings.error_prefix)}: ${err?.string ?: generalGetString(MR.strings.badges_error_unknown)}"
}
suspend fun apiGetBadgeState(rh: Long?, userId: Long): BadgeState? {
val r = sendCmd(rh, CC.ApiGetBadgeState(userId))
if (r is API.Result && r.res is CR.BadgeStateR) return r.res.badgeState
@@ -835,8 +824,8 @@ object ChatController {
}
}
private suspend fun sendCmdWithRetry(rhId: Long?, cmd: CC, inProgress: MutableState<Boolean>? = null, retryNum: Int = 0): API? {
val r = sendCmd(rhId, cmd, retryNum = retryNum)
private suspend fun sendCmdWithRetry(rhId: Long?, cmd: CC, inProgress: MutableState<Boolean>? = null, retryNum: Int = 0, log: Boolean = true): API? {
val r = sendCmd(rhId, cmd, retryNum = retryNum, log = log)
val alert = if (r is API.Error) retryableNetworkErrorAlert(r.err) else null
if ((inProgress == null || inProgress.value) && alert != null) {
return suspendCancellableCoroutine { cont ->
@@ -856,7 +845,7 @@ object ChatController {
safeResume(
runCatching {
coroutineScope {
sendCmdWithRetry(rhId, cmd, inProgress = inProgress, retryNum = retryNum + 1)
sendCmdWithRetry(rhId, cmd, inProgress = inProgress, retryNum = retryNum + 1, log = log)
}
}
)
@@ -919,6 +908,10 @@ object ChatController {
else -> null
}
}
is AgentErrorType.AGENT ->
if (e.agentErr is SMPAgentError.A_SERVICE && e.agentErr.serviceError is AgentServiceError.Timeout) {
return MR.strings.connection_timeout to generalGetString(MR.strings.service_request_timeout_desc)
}
else -> return null
}
return null
@@ -3565,11 +3558,13 @@ object ChatController {
}
}
is CR.BadgeChanged ->
if (active(r.user)) {
if (rhId == chatModel.remoteHostId()) {
withContext(Dispatchers.Main) {
// read by core after retiring or presenting, so it carries the profile badge as changed
chatModel.updateUser(r.user)
BadgeModel.set(rhId, r.user.userId, r.badgeState)
chatModel.updateUser(r.user.updateRemoteHostId(rhId))
if (active(r.user)) {
BadgeModel.set(rhId, r.user.userId, r.badgeState)
}
}
}
is CR.BadgeAlertR ->
@@ -3875,41 +3870,10 @@ class SharedPreference<T>(val get: () -> T, set: (T) -> Unit) {
}
}
// The failures redeemBadgeCode raises, as core flattens them to command error text.
// tests/Bots/BadgeServiceTests.hs asserts that text, so a change in core breaks a test there.
enum class BadgeRedeemError {
InvalidCode,
ServiceNotConfigured,
AlreadyActive,
CodeInvalid,
CodeUsed,
CodeExpired,
RateLimited,
ServiceFailed,
BadServiceResponse,
CredentialNotVerified,
UnsupportedVersion,
NetworkError,
BadgeEnded,
Unknown
}
private object BadgeErrorText {
const val invalidCode = "invalid badge code"
const val serviceNotConfigured = "badge service not configured"
const val alreadyActive = "badge already active"
const val unknownKeyIndex = "unknown badge key index"
const val credentialNotVerified = "badge credential does not verify against configured key"
const val invalidResponse = "invalid badge service response, "
const val unexpectedResponse = "unexpected badge service response: "
const val serviceError = "badge service error: "
// raised by sendServiceRequestTo, not by redeemBadgeCode itself, when the reply is not JSON
const val undecodableResponse = "invalid service response"
}
sealed class BadgeRedeemResult {
class Redeemed(val user: User, val newBadge: Boolean): BadgeRedeemResult()
class Failed(val error: BadgeRedeemError): BadgeRedeemResult()
class Redeemed(val user: User, val newBadge: Boolean, val badgeState: BadgeState?): BadgeRedeemResult()
// err is null for a response of an unexpected type, which is logged where it is received
class Failed(val err: ChatError?): BadgeRedeemResult()
}
// ChatCommand
@@ -4317,7 +4281,7 @@ sealed class CC {
is ApiStandaloneFileInfo -> "/_download info $url"
is ApiRedeemBadgeCode -> "/_redeem_badge_code $userId $code"
is ApiGetBadgeState -> "/_badge state $userId"
is ApiAckBadgeAlert -> "/_badge ack $userId $badgePurchaseId ${alertKind.text} ${onOff(snooze)} $episode"
is ApiAckBadgeAlert -> "/_badge ack $userId $badgePurchaseId ${badgeAlertKindParam(alertKind)} ${onOff(snooze)} $episode"
is ShowVersion -> "/version"
is ResetAgentServersStats -> "/reset servers stats"
is GetAgentSubsTotal -> "/get subs total $userId"
@@ -4559,6 +4523,15 @@ sealed class CC {
fun onOff(b: Boolean): String = if (b) "on" else "off"
// /_badge ack takes the kind in core's text encoding, not the JSON tag
private fun badgeAlertKindParam(kind: BadgeAlertKind): String = when (kind) {
BadgeAlertKind.RenewalApproaching -> "renewal_approaching"
BadgeAlertKind.PaymentIssue -> "payment_issue"
BadgeAlertKind.SubscriptionEnded -> "subscription_ended"
BadgeAlertKind.PrepaidEnding -> "prepaid_ending"
BadgeAlertKind.SupportEnded -> "support_ended"
}
@Serializable
data class NewUser(
val profile: Profile?,
@@ -6879,7 +6852,7 @@ sealed class CR {
@Serializable @SerialName("agentServersSummary") class AgentServersSummary(val user: UserRef, val serversSummary: PresentedServersSummary): CR()
// badges
// the full user, not UserRef: its profile carries the badge that setUserBadge just stored
@Serializable @SerialName("badgeRedeemed") class BadgeRedeemed(val user: User, val redeemedBadge: LocalBadge, val newBadge: Boolean): CR()
@Serializable @SerialName("badgeRedeemed") class BadgeRedeemed(val user: User, val redeemedBadge: LocalBadge, val newBadge: Boolean, val badgeState: BadgeState?): CR()
@Serializable @SerialName("badgeState") class BadgeStateR(val user: UserRef, val badgeState: BadgeState?): CR()
@Serializable @SerialName("badgeChanged") class BadgeChanged(val user: User, val badgeState: BadgeState?): CR()
@Serializable @SerialName("badgeAlert") class BadgeAlertR(val user: UserRef, val badgeAlert: BadgeAlert): CR()
@@ -7276,7 +7249,7 @@ sealed class CR {
is ArchiveExported -> "${archiveErrors.map { it.string } }"
is ArchiveImported -> "${archiveErrors.map { it.string } }"
is AppSettingsR -> json.encodeToString(appSettings)
is BadgeRedeemed -> withUser(user, "redeemedBadge: ${json.encodeToString(redeemedBadge)}\nnewBadge: $newBadge")
is BadgeRedeemed -> withUser(user, "redeemedBadge: ${json.encodeToString(redeemedBadge)}\nnewBadge: $newBadge\nbadgeState: ${json.encodeToString(badgeState)}")
is BadgeStateR -> withUser(user, json.encodeToString(badgeState))
is BadgeChanged -> withUser(user, json.encodeToString(badgeState))
is BadgeAlertR -> withUser(user, json.encodeToString(badgeAlert))
@@ -7331,6 +7304,97 @@ sealed class SimplexDomainError {
@Serializable @SerialName("unknownDomain") object UnknownDomain : SimplexDomainError()
}
@Serializable
sealed class BadgeRedeemError {
val string: String get() = when (this) {
is InvalidCode -> "invalidCode"
is ServiceNotConfigured -> "serviceNotConfigured"
is BadgeActive -> "badgeActive"
is ServiceError -> "serviceError ${serviceError.text}"
is InvalidResponse -> "invalidResponse $message"
is UnknownKeyIndex -> "unknownKeyIndex"
is CredentialNotVerified -> "credentialNotVerified"
}
@Serializable @SerialName("invalidCode") object InvalidCode : BadgeRedeemError()
@Serializable @SerialName("serviceNotConfigured") object ServiceNotConfigured : BadgeRedeemError()
@Serializable @SerialName("badgeActive") object BadgeActive : BadgeRedeemError()
@Serializable @SerialName("serviceError") class ServiceError(val serviceError: BadgeServiceErrorCode) : BadgeRedeemError()
@Serializable @SerialName("invalidResponse") class InvalidResponse(val message: String) : BadgeRedeemError()
@Serializable @SerialName("unknownKeyIndex") object UnknownKeyIndex : BadgeRedeemError()
@Serializable @SerialName("credentialNotVerified") object CredentialNotVerified : BadgeRedeemError()
}
// the service is deployed ahead of clients, so a code this version does not know keeps its tag
@Serializable(with = BadgeServiceErrorCodeSerializer::class)
sealed class BadgeServiceErrorCode {
object BadRequest: BadgeServiceErrorCode()
object UnsupportedVersion: BadgeServiceErrorCode()
object UnknownPurchaseKey: BadgeServiceErrorCode()
object UnknownOfferId: BadgeServiceErrorCode()
object OfferDisabled: BadgeServiceErrorCode()
object OfferMismatch: BadgeServiceErrorCode()
object ProductUnavailable: BadgeServiceErrorCode()
object PaymentNotEntitled: BadgeServiceErrorCode()
object PaymentPending: BadgeServiceErrorCode()
object ProviderUnavailable: BadgeServiceErrorCode()
object RateLimited: BadgeServiceErrorCode()
object CodeInvalid: BadgeServiceErrorCode()
object CodeUsed: BadgeServiceErrorCode()
object CodeExpired: BadgeServiceErrorCode()
object ReceiptInvalid: BadgeServiceErrorCode()
object ReceiptUsed: BadgeServiceErrorCode()
object Internal: BadgeServiceErrorCode()
data class Unknown(val code: String): BadgeServiceErrorCode()
val text: String
get() = when (this) {
is BadRequest -> "bad_request"
is UnsupportedVersion -> "unsupported_version"
is UnknownPurchaseKey -> "unknown_purchase_key"
is UnknownOfferId -> "unknown_offer_id"
is OfferDisabled -> "offer_disabled"
is OfferMismatch -> "offer_mismatch"
is ProductUnavailable -> "product_unavailable"
is PaymentNotEntitled -> "payment_not_entitled"
is PaymentPending -> "payment_pending"
is ProviderUnavailable -> "provider_unavailable"
is RateLimited -> "rate_limited"
is CodeInvalid -> "code_invalid"
is CodeUsed -> "code_used"
is CodeExpired -> "code_expired"
is ReceiptInvalid -> "receipt_invalid"
is ReceiptUsed -> "receipt_used"
is Internal -> "internal"
is Unknown -> code
}
}
object BadgeServiceErrorCodeSerializer : KSerializer<BadgeServiceErrorCode> {
override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("BadgeServiceErrorCode", PrimitiveKind.STRING)
override fun deserialize(decoder: Decoder): BadgeServiceErrorCode =
when (val v = decoder.decodeString()) {
"bad_request" -> BadgeServiceErrorCode.BadRequest
"unsupported_version" -> BadgeServiceErrorCode.UnsupportedVersion
"unknown_purchase_key" -> BadgeServiceErrorCode.UnknownPurchaseKey
"unknown_offer_id" -> BadgeServiceErrorCode.UnknownOfferId
"offer_disabled" -> BadgeServiceErrorCode.OfferDisabled
"offer_mismatch" -> BadgeServiceErrorCode.OfferMismatch
"product_unavailable" -> BadgeServiceErrorCode.ProductUnavailable
"payment_not_entitled" -> BadgeServiceErrorCode.PaymentNotEntitled
"payment_pending" -> BadgeServiceErrorCode.PaymentPending
"provider_unavailable" -> BadgeServiceErrorCode.ProviderUnavailable
"rate_limited" -> BadgeServiceErrorCode.RateLimited
"code_invalid" -> BadgeServiceErrorCode.CodeInvalid
"code_used" -> BadgeServiceErrorCode.CodeUsed
"code_expired" -> BadgeServiceErrorCode.CodeExpired
"receipt_invalid" -> BadgeServiceErrorCode.ReceiptInvalid
"receipt_used" -> BadgeServiceErrorCode.ReceiptUsed
"internal" -> BadgeServiceErrorCode.Internal
else -> BadgeServiceErrorCode.Unknown(v)
}
override fun serialize(encoder: Encoder, value: BadgeServiceErrorCode) = encoder.encodeString(value.text)
}
data class ConnectionPlanResult(
val connLink: CreatedConnLink,
val planSimplexName: SimplexNameInfo?,
@@ -7736,6 +7800,7 @@ sealed class ChatErrorType {
is AgentVersion -> "agentVersion"
is AgentNoSubResult -> "agentNoSubResult"
is CommandError -> "commandError $message"
is CEBadgeRedeemError -> "badgeRedeemError ${badgeRedeemError.string}"
is ServerProtocol -> "serverProtocol"
is AgentCommandError -> "agentCommandError"
is InvalidFileDescription -> "invalidFileDescription"
@@ -7820,6 +7885,7 @@ sealed class ChatErrorType {
@Serializable @SerialName("agentVersion") object AgentVersion: ChatErrorType()
@Serializable @SerialName("agentNoSubResult") class AgentNoSubResult(val agentConnId: String): ChatErrorType()
@Serializable @SerialName("commandError") class CommandError(val message: String): ChatErrorType()
@Serializable @SerialName("badgeRedeemError") class CEBadgeRedeemError(val badgeRedeemError: BadgeRedeemError): ChatErrorType()
@Serializable @SerialName("serverProtocol") object ServerProtocol: ChatErrorType()
@Serializable @SerialName("agentCommandError") class AgentCommandError(val message: String): ChatErrorType()
@Serializable @SerialName("invalidFileDescription") class InvalidFileDescription(val message: String): ChatErrorType()
@@ -8254,6 +8320,7 @@ sealed class SMPAgentError {
is A_CRYPTO -> "A_CRYPTO"
is A_DUPLICATE -> "A_DUPLICATE"
is A_QUEUE -> "A_QUEUE"
is A_SERVICE -> "A_SERVICE ${serviceError.string}"
}
@Serializable @SerialName("A_MESSAGE") object A_MESSAGE: SMPAgentError()
@Serializable @SerialName("A_PROHIBITED") class A_PROHIBITED(val prohibitedErr: String): SMPAgentError()
@@ -8262,6 +8329,23 @@ sealed class SMPAgentError {
@Serializable @SerialName("A_CRYPTO") object A_CRYPTO: SMPAgentError()
@Serializable @SerialName("A_DUPLICATE") object A_DUPLICATE: SMPAgentError()
@Serializable @SerialName("A_QUEUE") class A_QUEUE(val queueErr: String): SMPAgentError()
@Serializable @SerialName("A_SERVICE") class A_SERVICE(val serviceError: AgentServiceError): SMPAgentError()
}
@Serializable
sealed class AgentServiceError {
val string: String get() = when (this) {
is Rejected -> "rejected"
is Timeout -> "timeout"
is NoPendingRequest -> "noPendingRequest"
is NotDRAddress -> "notDRAddress"
is BadSignature -> "badSignature"
}
@Serializable @SerialName("rejected") object Rejected: AgentServiceError()
@Serializable @SerialName("timeout") object Timeout: AgentServiceError()
@Serializable @SerialName("noPendingRequest") object NoPendingRequest: AgentServiceError()
@Serializable @SerialName("notDRAddress") object NotDRAddress: AgentServiceError()
@Serializable @SerialName("badSignature") object BadSignature: AgentServiceError()
}
@Serializable
@@ -40,6 +40,13 @@ external fun chatReadFile(path: String, key: String, nonce: String): Array<Any>
external fun chatEncryptFile(ctrl: ChatCtrl, fromPath: String, toPath: String): String
external fun chatDecryptFile(fromPath: String, key: String, nonce: String, toPath: String): String
// the code in core's canonical form (prefix and 20 characters, no separators), or null when core rejects it.
// The check character is verified by core via FFI, not re-implemented here, so the two cannot disagree.
fun parseBadgeCode(s: String): String? {
val canonical = chatParseBadgeCode(s)
return if (canonical.isEmpty()) null else canonical
}
val chatModel: ChatModel
get() = chatController.chatModel
@@ -21,7 +21,6 @@ import androidx.compose.ui.text.input.KeyboardCapitalization
import androidx.compose.ui.text.input.TextFieldValue
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import dev.icerock.moko.resources.StringResource
import dev.icerock.moko.resources.compose.stringResource
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
@@ -39,13 +38,6 @@ private const val badgeCodePrefix = "SB"
private const val badgeCodeBodyLength = 20
private const val badgeCodeGroupLength = 5
// The code as core will accept it - prefix and 20 characters, no separators - or null if it does not
// parse. Validity is decided only here: a second check-character implementation would drift.
fun parseBadgeCode(s: String): String? {
val canonical = chatParseBadgeCode(s)
return if (canonical.isEmpty()) null else canonical
}
// Regroups what was typed; validity and the folding of ambiguous characters are core's alone.
private fun formatBadgeCodeInput(s: String): String {
val normalized = StringBuilder()
@@ -73,9 +65,11 @@ fun BadgesRedeemCodeView() {
val canonicalCode = remember { mutableStateOf<String?>(null) }
val submitting = remember { mutableStateOf(false) }
fun applyCodeInput(s: String) {
val formatted = formatBadgeCodeInput(s)
if (formatted != code.value.text) code.value = TextFieldValue(formatted, selection = TextRange(formatted.length))
// when the text is unchanged, the field's own value is kept: it carries the cursor position and the
// keyboard's composition state, which BasicTextField loses unless they are passed back to it
fun applyCodeInput(v: TextFieldValue) {
val formatted = formatBadgeCodeInput(v.text)
code.value = if (formatted != v.text) TextFieldValue(formatted, selection = TextRange(formatted.length)) else v
canonicalCode.value = parseBadgeCode(formatted)
}
@@ -85,23 +79,20 @@ fun BadgesRedeemCodeView() {
submitting.value = true
withBGApi {
when (val result = chatModel.controller.apiRedeemBadgeCode(rhId, user.userId, sending)) {
null -> withContext(Dispatchers.Main) { submitting.value = false }
is BadgeRedeemResult.Redeemed -> {
val badgeState = try { chatModel.controller.apiGetBadgeState(rhId, user.userId) } catch (e: Exception) { null }
val badgeState = result.badgeState
withContext(Dispatchers.Main) {
submitting.value = false
// written before the pop: BadgesView swaps its content under this pushed view, so
// the pop reveals Your Badge already in place rather than animating it afterwards
if (badgeState != null) {
BadgeModel.set(rhId, user.userId, badgeState)
}
// the response is the only carrier: redeeming raises no event that refreshes the
// profile, so without this the badge beside the name is the one from before
// set before dismissing: BadgesView then switches Support to Your Badge while this screen
// still covers it, so the pop lands on Your Badge instead of showing the switch
BadgeModel.set(rhId, user.userId, badgeState)
chatModel.updateUser(result.user)
if (badgeState != null && !badgeState.shown) {
// a replay adds no purchase; a fresh code's badge can be retired on arrival
AlertManager.shared.showAlertMsg(
title = generalGetString(MR.strings.badges_error_title),
text = generalGetString(failureMessage(if (result.newBadge) BadgeRedeemError.BadgeEnded else BadgeRedeemError.CodeUsed))
text = generalGetString(if (result.newBadge) MR.strings.badges_error_badge_ended else MR.strings.badges_error_code_used)
)
} else {
supporterBannerShown.set(true)
@@ -110,13 +101,12 @@ fun BadgesRedeemCodeView() {
}
}
is BadgeRedeemResult.Failed -> {
// the mapped case only - core embeds the service's response in some of these messages
Log.e(TAG, "apiRedeemBadgeCode: ${result.error}")
Log.e(TAG, "apiRedeemBadgeCode: ${result.err?.string}")
withContext(Dispatchers.Main) {
submitting.value = false
AlertManager.shared.showAlertMsg(
title = generalGetString(MR.strings.badges_error_title),
text = generalGetString(failureMessage(result.error))
text = chatModel.controller.redeemErrorText(result.err)
)
}
}
@@ -163,7 +153,7 @@ fun BadgesRedeemCodeView() {
false
}
else -> {
applyCodeInput(formatted)
applyCodeInput(TextFieldValue(formatted, selection = TextRange(formatted.length)))
redeem()
true
}
@@ -181,7 +171,7 @@ fun BadgesRedeemCodeView() {
}
@Composable
private fun CodeField(code: MutableState<TextFieldValue>, submitting: Boolean, applyCodeInput: (String) -> Unit) {
private fun CodeField(code: MutableState<TextFieldValue>, submitting: Boolean, applyCodeInput: (TextFieldValue) -> Unit) {
val colors = TextFieldDefaults.textFieldColors(
backgroundColor = MaterialTheme.appColors.sentMessage,
textColor = MaterialTheme.colors.onBackground,
@@ -190,7 +180,7 @@ private fun CodeField(code: MutableState<TextFieldValue>, submitting: Boolean, a
)
BasicTextField(
value = code.value,
onValueChange = { applyCodeInput(it.text) },
onValueChange = applyCodeInput,
enabled = !submitting,
singleLine = true,
textStyle = TextStyle.Default.copy(
@@ -218,10 +208,10 @@ private fun CodeField(code: MutableState<TextFieldValue>, submitting: Boolean, a
}
@Composable
private fun PasteButton(submitting: Boolean, applyCodeInput: (String) -> Unit) {
private fun PasteButton(submitting: Boolean, applyCodeInput: (TextFieldValue) -> Unit) {
val clipboard = LocalClipboardManager.current
TextButton(
onClick = { clipboard.getText()?.text?.let { applyCodeInput(it) } },
onClick = { clipboard.getText()?.text?.let { applyCodeInput(TextFieldValue(it, selection = TextRange(it.length))) } },
enabled = !submitting
) {
Text(stringResource(MR.strings.paste_button), color = MaterialTheme.colors.primary, fontWeight = FontWeight.Medium)
@@ -238,20 +228,3 @@ private fun SubmitButton(enabled: Boolean, onClick: () -> Unit) {
onclick = onClick
)
}
private fun failureMessage(failure: BadgeRedeemError): StringResource = when (failure) {
BadgeRedeemError.InvalidCode -> MR.strings.badges_error_invalid_code
BadgeRedeemError.ServiceNotConfigured -> MR.strings.badges_error_service_not_configured
BadgeRedeemError.AlreadyActive -> MR.strings.badges_error_already_active
BadgeRedeemError.CodeInvalid -> MR.strings.badges_error_code_invalid
BadgeRedeemError.CodeUsed -> MR.strings.badges_error_code_used
BadgeRedeemError.CodeExpired -> MR.strings.badges_error_code_expired
BadgeRedeemError.RateLimited -> MR.strings.badges_error_rate_limited
BadgeRedeemError.ServiceFailed -> MR.strings.badges_error_service_failed
BadgeRedeemError.BadServiceResponse -> MR.strings.badges_error_bad_service_response
BadgeRedeemError.CredentialNotVerified -> MR.strings.badges_error_credential_not_verified
BadgeRedeemError.UnsupportedVersion -> MR.strings.badges_error_unsupported_version
BadgeRedeemError.NetworkError -> MR.strings.badges_error_network
BadgeRedeemError.BadgeEnded -> MR.strings.badges_error_badge_ended
BadgeRedeemError.Unknown -> MR.strings.badges_error_unknown
}
@@ -15,7 +15,7 @@ fun BadgesView() {
if (badgeState != null && badgeState.shown) badgeState else null
}
AnimatedContent(targetState = shownBadge, transitionSpec = { fadeIn() with fadeOut() }) { badgeState ->
AnimatedContent(targetState = shownBadge, transitionSpec = { fadeIn() with fadeOut() }, contentKey = { it != null }) { badgeState ->
if (badgeState != null) {
BadgesYourBadgeView(badgeState)
} else {
@@ -16,25 +16,23 @@ import androidx.compose.ui.unit.dp
import dev.icerock.moko.resources.compose.painterResource
import dev.icerock.moko.resources.compose.stringResource
import chat.simplex.common.model.BadgeState
import chat.simplex.common.model.BadgeType
import chat.simplex.common.platform.ColumnWithScrollBar
import chat.simplex.common.ui.theme.DEFAULT_PADDING
import chat.simplex.common.views.helpers.AppBarTitle
import chat.simplex.common.views.helpers.badgeImage
import chat.simplex.common.views.helpers.badgeTypeName
import chat.simplex.res.MR
@Composable
fun BadgesYourBadgeView(badgeState: BadgeState) {
val title = if (badgeState.shown) MR.strings.badges_your_badge else MR.strings.badges_support_ended
ColumnWithScrollBar {
AppBarTitle(stringResource(title))
AppBarTitle(stringResource(MR.strings.badges_your_badge))
SectionView {
BadgeSummary(badgeState)
}
SectionSpacer()
SectionView(stringResource(MR.strings.badges_ends).uppercase()) {
SectionView(stringResource(MR.strings.badges_ends)) {
Text(badgeState.paidThroughText, Modifier.padding(horizontal = DEFAULT_PADDING, vertical = 12.dp))
}
SectionTextFooter(stringResource(MR.strings.badges_prepaid_footer))
@@ -65,12 +63,3 @@ fun BadgeSummary(badgeState: BadgeState) {
)
}
}
// verbatim for an unknown type: it is the service's string, and must not be looked up as a localised key
@Composable
private fun badgeTypeName(t: BadgeType): String = when (t) {
is BadgeType.Supporter -> stringResource(MR.strings.badges_level_supporter)
is BadgeType.Legend -> stringResource(MR.strings.badges_level_legend)
is BadgeType.Investor -> stringResource(MR.strings.badges_type_investor)
is BadgeType.Unknown -> t.type
}
@@ -79,7 +79,7 @@ private fun showSupportEndedDismissAlert() {
AlertManager.shared.hideAlert()
withBGApi { chatModel.controller.ackBadgeAlert(snooze = false) }
}) {
Text(stringResource(MR.strings.badges_dont_show_again), Modifier.fillMaxWidth(), textAlign = TextAlign.Center, color = MaterialTheme.colors.primary)
Text(stringResource(MR.strings.badges_dismiss), Modifier.fillMaxWidth(), textAlign = TextAlign.Center, color = MaterialTheme.colors.primary)
}
SectionItemView({
AlertManager.shared.hideAlert()
@@ -1051,7 +1051,7 @@ private fun BoxScope.ChatList(searchText: MutableState<TextFieldValue>, listStat
)
}
}
} else if (!supporterBannerShown.value && chatModel.chats.value.size > 3) {
} else if (!supporterBannerShown.value && !hasShownBadge() && chatModel.chats.value.size > 3) {
item {
Box(Modifier.zIndex(1f).padding(16.dp)) {
SupportSimpleXBanner(
@@ -207,9 +207,17 @@ private fun BadgeGlyph(badge: LocalBadge, modifier: Modifier, onBadgeClick: (()
}
}
// verbatim for an unknown type: it is the service's string, and must not be looked up as a localised key
fun badgeTypeName(t: BadgeType): String = when (t) {
is BadgeType.Supporter -> generalGetString(MR.strings.badges_level_supporter)
is BadgeType.Legend -> generalGetString(MR.strings.badges_level_legend)
is BadgeType.Investor -> generalGetString(MR.strings.badges_type_investor)
is BadgeType.Unknown -> t.type
}
fun showBadgeInfoAlert(name: String, badge: LocalBadge, uriHandler: UriHandler) {
// a verified badge's type is signed and can't be faked, so the real (possibly unknown) type name is the title
val title = badge.badge.badgeType.text.replaceFirstChar { it.uppercase() }
val title = badgeTypeName(badge.badge.badgeType)
when {
badge.status == BadgeStatus.Failed ->
AlertManager.shared.showAlertMsg(
@@ -54,6 +54,9 @@ fun shouldShowOnboarding(): Boolean {
fun supportEnded(): Boolean =
BadgeModel.alert.value?.kind == BadgeAlertKind.SupportEnded && BadgeModel.isCurrent(chatModel.remoteHostId(), chatModel.currentUser.value?.userId)
fun hasShownBadge(): Boolean =
BadgeModel.badgeState.value?.shown == true && BadgeModel.isCurrent(chatModel.remoteHostId(), chatModel.currentUser.value?.userId)
fun hasConversations(chats: List<Chat>): Boolean =
chats.any { chat ->
when (val c = chat.chatInfo) {
@@ -178,6 +178,7 @@
<string name="proxy_destination_error_failed_to_connect">Forwarding server %1$s failed to connect to destination server %2$s. Please try later.</string>
<string name="proxy_destination_error_broker_host">Destination server address of %1$s is incompatible with forwarding server %2$s settings.</string>
<string name="proxy_destination_error_broker_version">Destination server version of %1$s is incompatible with forwarding server %2$s.</string>
<string name="service_request_timeout_desc">The service did not respond. Please try again.</string>
<string name="please_try_later">Please try later.</string>
<string name="error_sending_message">Error sending message</string>
<string name="error_forwarding_messages">Error forwarding messages</string>
@@ -3251,11 +3252,9 @@
<string name="badges_error_code_used">This code has already been used.</string>
<string name="badges_error_code_expired">This code has expired.</string>
<string name="badges_error_rate_limited">Too many attempts. Please try again later.</string>
<string name="badges_error_service_failed">The badge service is unavailable. Please try again later.</string>
<string name="badges_error_bad_service_response">The badge service sent an unexpected response.</string>
<string name="badges_error_bad_service_response">The badge service sent an unexpected response: %1$s</string>
<string name="badges_error_credential_not_verified">This app version cannot verify this badge. Please update the app.</string>
<string name="badges_error_unsupported_version">This app version is too old for the badge service. Please update the app.</string>
<string name="badges_error_network">Connection error. Please check your network connection.</string>
<string name="badges_error_badge_ended">The code was accepted, but the badge it grants has already ended.</string>
<string name="badges_error_unknown">The code could not be redeemed.</string>
<string name="badges_code_you_scanned_is_not_badge_code">The code you scanned is not a badge code.</string>
@@ -3267,7 +3266,7 @@
<string name="badges_type_investor">Investor</string>
<string name="badges_support_ended_on">Your support ended on %1$s.</string>
<string name="badges_remind_me_later">Remind me later</string>
<string name="badges_dont_show_again">Don\'t show again</string>
<string name="badges_dismiss">Dismiss</string>
<string name="supporter_perks">Supporter perks</string>
<string name="v7_1_supporter_badge_title">Supporter badge ❤️</string>
<string name="v7_1_supporter_badge_body">Help keep the network running — send files up to 2 GB.</string>
+10 -6
View File
@@ -24,6 +24,7 @@ module Simplex.Chat.Badges.Types
BadgeCharge (..),
BadgeIssuance (..),
BadgeAlert (..),
BadgeAlertPrice (..),
BadgeState (..),
) where
@@ -204,7 +205,13 @@ data BadgeAlert = BadgeAlert
{ kind :: BadgeAlertKind,
episode :: Text,
date :: UTCTime,
price :: Maybe (Int64, Text)
price :: Maybe BadgeAlertPrice
}
deriving (Show)
data BadgeAlertPrice = BadgeAlertPrice
{ amount :: Int64,
currency :: Text
}
deriving (Show)
@@ -259,12 +266,9 @@ $(JQ.deriveJSON (enumJSON $ dropPrefix "BIS") ''BadgeItemStatus)
$(JQ.deriveJSON (taggedObjectJSON $ dropPrefix "OD") ''OfferDiscount)
instance ToJSON BadgeAlertKind where
toJSON = textToJSON
toEncoding = textToEncoding
$(JQ.deriveJSON (enumJSON $ dropPrefix "BA") ''BadgeAlertKind)
instance FromJSON BadgeAlertKind where
parseJSON = textParseJSON "BadgeAlertKind"
$(JQ.deriveJSON defaultJSON ''BadgeAlertPrice)
$(JQ.deriveJSON defaultJSON ''BadgeAlert)
+15 -1
View File
@@ -84,6 +84,7 @@ import qualified Simplex.Messaging.Agent.Store.DB as DB
import Simplex.Messaging.Client (HostMode (..), SMPProxyFallback (..), SMPProxyMode (..), SMPWebPortServers (..), SocksMode (..))
import qualified Simplex.Messaging.Crypto as C
import Simplex.Chat.Badges (BadgeCredential, FileSizeLimits, LocalBadge)
import Simplex.Chat.Badges.Service (BadgeServiceErrorCode)
import Simplex.Chat.Badges.Types (BadgeAlert (..), BadgeAlertKind, BadgeState (..))
import Simplex.Messaging.Crypto.BBS (BBSPublicKey)
import Simplex.Messaging.Crypto.File (CryptoFile (..))
@@ -866,7 +867,7 @@ data ChatResponse
| CRContactRequestRejected {user :: User, contactRequest :: UserContactRequest, contact_ :: Maybe Contact}
| CRServiceResponse {user :: User, responseData :: J.Object}
| CRServiceReplyAccepted {user :: User, connectionId :: AgentConnId}
| CRBadgeRedeemed {user :: User, redeemedBadge :: LocalBadge, newBadge :: Bool}
| CRBadgeRedeemed {user :: User, redeemedBadge :: LocalBadge, newBadge :: Bool, badgeState :: Maybe BadgeState}
| CRBadgeState {user :: User, badgeState :: Maybe BadgeState}
| CRUserAcceptedGroupSent {user :: User, groupInfo :: GroupInfo, hostContact :: Maybe Contact}
| CRUserDeletedMembers {user :: User, groupInfo :: GroupInfo, members :: [GroupMember], withMessages :: Bool, msgSigned :: Bool}
@@ -1476,6 +1477,16 @@ data SimplexDomainError
| SDEUnknownDomain -- the resolved link's profile has no name, or a different name
deriving (Eq, Show)
data BadgeRedeemError
= BREInvalidCode -- format or check character
| BREServiceNotConfigured
| BREBadgeActive
| BREServiceError {serviceError :: BadgeServiceErrorCode}
| BREInvalidResponse {message :: String}
| BREUnknownKeyIndex
| BRECredentialNotVerified
deriving (Eq, Show)
data ChatErrorType
= CENoActiveUser
| CENoConnectionUser {agentConnId :: AgentConnId}
@@ -1548,6 +1559,7 @@ data ChatErrorType
| CEAgentVersion
| CEAgentNoSubResult {agentConnId :: AgentConnId}
| CECommandError {message :: String}
| CEBadgeRedeemError {badgeRedeemError :: BadgeRedeemError}
| CEServerProtocol {serverProtocol :: AProtocolType}
| CEAgentCommandError {message :: String}
| CEInvalidFileDescription {message :: String}
@@ -1832,6 +1844,8 @@ $(JQ.deriveJSON (sumTypeJSON $ dropPrefix "FC") ''ForwardConfirmation)
$(JQ.deriveJSON (sumTypeJSON $ dropPrefix "SDE") ''SimplexDomainError)
$(JQ.deriveJSON (sumTypeJSON $ dropPrefix "BRE") ''BadgeRedeemError)
$(JQ.deriveJSON (sumTypeJSON $ dropPrefix "CE") ''ChatErrorType)
$(JQ.deriveJSON (sumTypeJSON $ dropPrefix "RHE") ''RemoteHostError)
+24 -17
View File
@@ -3570,7 +3570,7 @@ processChatCommand cxt nm = \case
APIAckBadgeAlert userId badgePurchaseId alertKind snooze episode -> withUserId userId $ \user -> do
now <- badgeNow
let snoozeUntil = if snooze then Just (addUTCTime nominalDay now) else Nothing
withStore' $ \db -> setBadgeAlertAcked db badgePurchaseId alertKind episode snoozeUntil
withStore' $ \db -> setBadgeAlertAcked db user badgePurchaseId alertKind episode snoozeUntil
-- after the write, so the pass it signals arms a wake for the snooze rather than raising again
lift $ startBadgeWork user
CRBadgeState user <$> getUserBadgeState user
@@ -5220,8 +5220,8 @@ presentUserBadgeToContacts user'@User {userId, profile = LocalProfile {localBadg
-- A terminal answer drops the stash; a timeout keeps it.
redeemBadgeCode :: NetworkRequestMode -> User -> Text -> CM ChatResponse
redeemBadgeCode nm user@User {userId} codeText = do
code <- maybe (throwCmdError "invalid badge code") pure $ parseBadgeCode codeText
sendTarget <- asks (badgeServiceAddress . config) >>= maybe (throwCmdError "badge service not configured") pure
code <- maybe (throwRedeemError BREInvalidCode) pure $ parseBadgeCode codeText
sendTarget <- asks (badgeServiceAddress . config) >>= maybe (throwRedeemError BREServiceNotConfigured) pure
g <- asks random
now <- liftIO getCurrentTime
let codeSent = badgeCodeText code
@@ -5232,24 +5232,23 @@ redeemBadgeCode nm user@User {userId} codeText = do
-- a code already redeemed here is allowed through: re-sending it returns the badge it bought
-- and adds nothing. Refused before its keys are stashed and before the request, so it stays unspent
replaying <- maybe (pure False) (\r -> withStore' $ \db -> isJust <$> getCodeBadgePurchase db r) redemption_
unless replaying $ whenM (withStore' (`userHasBadge` user)) $ throwCmdError "badge already active"
unless replaying $ whenM (withStore' (`userHasBadge` user)) $ throwRedeemError BREBadgeActive
redemption@BadgeCodeRedemption {purchaseKey, purchasePrivKey, masterKey} <-
maybe (withStore' $ \db -> createBadgeCodeRedemption db g user codeSent now) pure redemption_
let req = BadgeServiceRequest {version = currentBadgeServiceVersion, purchaseKey = Just purchaseKey, request = BSCRedeemBadgeCode {masterKey, code = codeSent}}
respData <- sendServiceRequestTo nm user sendTarget Nothing (Just purchasePrivKey) req
respBytes <- sendServiceRequestBytes nm user sendTarget Nothing (Just purchasePrivKey) req
respData <- either (const $ throwRedeemError $ BREInvalidResponse "not JSON") pure $ J.eitherDecodeStrict' respBytes
case J.fromJSON (J.Object respData) of
J.Error e -> throwCmdError $ "invalid badge service response, " <> show e <> ": " <> respJSON respData
J.Error _ -> throwRedeemError $ BREInvalidResponse "not a badge service response"
J.Success BSPError {code = errCode} -> do
when (terminalCodeError errCode) $ withStore' $ \db -> deleteBadgeCodeRedemption db (redemptionId redemption)
throwCmdError $ "badge service error: " <> T.unpack (badgeServiceErrorText errCode)
throwRedeemError $ BREServiceError errCode
J.Success BSPBadgeCredential {credential = Just cred, statement} -> storeRedeemedBadge user redemption cred statement
J.Success _ -> throwCmdError $ "unexpected badge service response: " <> respJSON respData
J.Success _ -> throwRedeemError $ BREInvalidResponse "unexpected response type"
-- outside the badge lock: the chat lock must not be taken under it
mapM_ presentUserBadgeToContacts present_
pure redeemed
where
-- re-encoded, not shown as received: JSON escapes the control characters a terminal acts on
respJSON = LB.unpack . J.encode
-- the code will never work, so the keys stashed for it are dead; a timeout keeps them
terminalCodeError = \case
BSECodeInvalid -> True
@@ -5257,6 +5256,9 @@ redeemBadgeCode nm user@User {userId} codeText = do
BSECodeExpired -> True
_ -> False
throwRedeemError :: BadgeRedeemError -> CM a
throwRedeemError = throwChatError . CEBadgeRedeemError
-- | An unknown code is reported, since the service is deployed ahead of clients, but its text is
-- the service's - so it is bounded and stripped before reaching a terminal that acts on controls.
badgeServiceErrorText :: BadgeServiceErrorCode -> Text
@@ -5584,11 +5586,11 @@ stopBadgeWorkers workers =
storeRedeemedBadge :: User -> BadgeCodeRedemption -> BadgeCredential -> BadgeStatement -> CM (Maybe User, ChatResponse)
storeRedeemedBadge user@User {userId} redemption@BadgeCodeRedemption {masterKey} cred@(BadgeCredential _ credMasterKey _ info@BadgeInfo {badgeType}) statement =
verifyOwnBadge cred >>= \case
Nothing -> throwCmdError "redeemed badge credential names an unknown badge key index"
Just False -> throwCmdError "redeemed badge credential does not verify against configured key"
Nothing -> throwRedeemError BREUnknownKeyIndex
Just False -> throwRedeemError BRECredentialNotVerified
-- verifyCredential checks the signature against the key inside the credential, not the one we
-- sent - so a credential over any other master key also verifies
Just True | credMasterKey /= masterKey -> throwCmdError "redeemed badge credential is for a different master key"
Just True | credMasterKey /= masterKey -> throwRedeemError $ BREInvalidResponse "credential is for a different master key"
Just True -> do
g <- asks random
now <- badgeNow
@@ -5603,7 +5605,8 @@ storeRedeemedBadge user@User {userId} redemption@BadgeCodeRedemption {masterKey}
unless applied $ eToView $ ChatError $ CEInternalError "redeemed badge credential has no ledger row to store it against"
-- nothing is due yet, but a pass is what arms the next wake, and this is the first purchase
lift $ startBadgeWork user'
pure (if newBadge then Just user' else Nothing, CRBadgeRedeemed user' badge newBadge)
badgeState <- getUserBadgeState user'
pure (if newBadge then Just user' else Nothing, CRBadgeRedeemed user' badge newBadge badgeState)
-- | Store the statement's rows, then the credential against the badge debit row among them.
-- 'False' when that row cannot be found, which the caller reports rather than drop in silence.
@@ -5627,10 +5630,14 @@ applyBadgeStatement db g purchaseId badgeType BadgeStatement {entries} cred_ now
ids -> Just (last ids)
sendServiceRequestTo :: J.ToJSON a => NetworkRequestMode -> User -> ConnectTarget 'CMContact -> Maybe NominalDiffTime -> Maybe C.PrivateKeyEd25519 -> a -> CM J.Object
sendServiceRequestTo nm user sendTarget requestTimeout signKey request = do
sendServiceRequestTo nm user sendTarget requestTimeout signKey request =
sendServiceRequestBytes nm user sendTarget requestTimeout signKey request
>>= either (const $ throwCmdError "invalid service response") pure . J.eitherDecodeStrict'
sendServiceRequestBytes :: J.ToJSON a => NetworkRequestMode -> User -> ConnectTarget 'CMContact -> Maybe NominalDiffTime -> Maybe C.PrivateKeyEd25519 -> a -> CM ByteString
sendServiceRequestBytes nm user sendTarget requestTimeout signKey request = do
cReq <- resolveServiceTarget sendTarget
respData <- withAgent $ \a -> sendServiceRequestAsync a (aUserId user) cReq requestTimeout signKey (LB.toStrict $ J.encode request)
either (const $ throwCmdError "invalid service response") pure $ J.eitherDecodeStrict' respData
withAgent $ \a -> sendServiceRequestAsync a (aUserId user) cReq requestTimeout signKey (LB.toStrict $ J.encode request)
where
resolveServiceTarget = \case
CTFullContact cReq -> pure cReq
+4 -4
View File
@@ -258,12 +258,12 @@ userHasBadge db User {userId} =
-- | An ack and a snooze both record the occurrence answered; a snooze also records how long it
-- holds, so that it silences that occurrence and not whichever one is derived next.
setBadgeAlertAcked :: DB.Connection -> Int64 -> BadgeAlertKind -> Text -> Maybe UTCTime -> IO ()
setBadgeAlertAcked db badgePurchaseId kind episode snoozeUntil =
setBadgeAlertAcked :: DB.Connection -> User -> Int64 -> BadgeAlertKind -> Text -> Maybe UTCTime -> IO ()
setBadgeAlertAcked db User {userId} badgePurchaseId kind episode snoozeUntil =
DB.execute
db
"UPDATE badge_purchases SET alert_acked_kind = ?, alert_acked_episode = ?, alert_snooze_until = ? WHERE badge_purchase_id = ?"
(kind, episode, snoozeUntil, badgePurchaseId)
"UPDATE badge_purchases SET alert_acked_kind = ?, alert_acked_episode = ?, alert_snooze_until = ? WHERE badge_purchase_id = ? AND user_id = ?"
(kind, episode, snoozeUntil, badgePurchaseId, userId)
-- | Stop showing a badge that has expired unrenewed; the profile update is broadcast by the caller.
clearShownBadge :: DB.Connection -> User -> Int64 -> IO ()
+12 -2
View File
@@ -41,7 +41,7 @@ import Numeric (showFFloat)
import Simplex.Chat.Call
import Simplex.Chat.Controller
import Simplex.Chat.Help
import Simplex.Chat.Library.Commands (maxImageSize)
import Simplex.Chat.Library.Commands (badgeServiceErrorText, maxImageSize)
import Simplex.Chat.Markdown
import Simplex.Chat.Badges (BadgeInfo (..), BadgeStatus (..), BadgeType (..), LocalBadge, localBadgeInfo, localBadgeStatus)
import Simplex.Chat.Badges.Types (BadgeAlert (..), BadgeState (..))
@@ -190,7 +190,7 @@ chatResponseToView hu cfg@ChatConfig {logLevel, showReactions, showFullLinks, te
CRServiceResponse u resp -> ttyUser u ["service response: " <> viewJSON resp]
CRServiceReplyAccepted u (AgentConnId cId) -> ttyUser u [plain $ "service reply accepted, connection id: " <> safeDecodeUtf8 (strEncode cId)]
-- the badge is only shown when it is the one now on the profile; a replayed code's badge may not be
CRBadgeRedeemed u badge newBadge -> ttyUser u $ if newBadge then "badge redeemed" : viewContactBadge (Just badge) else ["badge already redeemed"]
CRBadgeRedeemed u badge newBadge _ -> ttyUser u $ if newBadge then "badge redeemed" : viewContactBadge (Just badge) else ["badge already redeemed"]
CRBadgeState u st -> ttyUser u $ viewUserBadgeState st
CRGroupCreated u g -> ttyUser u $ viewGroupCreated g testView
CRPublicGroupCreated u g _groupLink _relays -> ttyUser u $ viewGroupCreated g testView
@@ -2841,6 +2841,16 @@ viewChatError isCmd logLevel testView = \case
CEAgentNoSubResult connId -> ["no subscription result for connection: " <> sShow connId]
CEServerProtocol p -> [plain $ "Servers for protocol " <> strEncode p <> " cannot be configured by the users"]
CECommandError e -> ["bad chat command: " <> plain e]
CEBadgeRedeemError e ->
let reason = case e of
BREInvalidCode -> "invalid code"
BREServiceNotConfigured -> "badge service not configured"
BREBadgeActive -> "badge already active"
BREServiceError code -> "badge service error: " <> T.unpack (badgeServiceErrorText code)
BREInvalidResponse m -> "invalid service response: " <> m
BREUnknownKeyIndex -> "credential names an unknown badge key index"
BRECredentialNotVerified -> "credential does not verify against configured key"
in ["cannot redeem badge code: " <> plain reason]
CEAgentCommandError e -> ["agent command error: " <> plain e]
CEInvalidFileDescription e -> ["invalid file description: " <> plain e]
CEConnectionIncognitoChangeProhibited -> ["incognito mode change prohibited"]
+4 -4
View File
@@ -257,10 +257,10 @@ testRedeemUnknownCode ps =
g <- C.newRandom
unknown <- randomBadgeCode g
alice ##> ("/_redeem_badge_code 1 " <> codeArg unknown)
alice <## "bad chat command: badge service error: code_invalid"
alice <## "cannot redeem badge code: badge service error: code_invalid"
-- a failed check character is refused before anything leaves the device
alice ##> "/_redeem_badge_code 1 SB-00000-00000-00000-00001"
alice <## "bad chat command: invalid badge code"
alice <## "cannot redeem badge code: invalid code"
-- sent straight to the service, past the client's own check, the two are one answer
(_, redeemPriv) <- atomically $ C.generateKeyPair g :: IO (C.KeyPair 'C.Ed25519)
redeemDirect alice bsLink redeemPriv (T.unpack $ badgeCodeText unknown)
@@ -315,7 +315,7 @@ testRedeemSecondCode ps =
alice <## "supporter badge - active"
alice <##. "expires "
alice ##> ("/_redeem_badge_code 1 " <> codeArg legend)
alice <## "bad chat command: badge already active"
alice <## "cannot redeem badge code: badge already active"
alice ##> "/p"
showActiveUser alice "alice (Alice, * supporter)"
alice ##> "/create user alisa"
@@ -339,7 +339,7 @@ testRedeemSameCodeOtherProfile ps =
alice ##> "/create user alisa"
showActiveUser alice "alisa"
alice ##> ("/_redeem_badge_code 2 " <> codeArg code)
alice <## "bad chat command: badge service error: code_used"
alice <## "cannot redeem badge code: badge service error: code_used"
alice ##> "/p"
showActiveUser alice "alisa"
alice ##> "/user alice"