damus

LnurlAmountView.swift (9165B)

---

 //
 //  LnurlAmountView.swift
 //  damus
 //
 //  Created by Daniel D’Aquino on 2025-06-18
 //
 
 import SwiftUI
 import Combine
 
 class LnurlAmountModel: ObservableObject {
     @Published var custom_amount: String = "0"
     @Published var custom_amount_sats: Int? = 0
     @Published var processing: Bool = false
     @Published var error: String? = nil
     @Published var invoice: String? = nil
     @Published var zap_amounts: [ZapAmountItem] = []
     
     func set_defaults(settings: UserSettingsStore) {
         let default_amount = settings.default_zap_amount
         custom_amount = String(default_amount)
         custom_amount_sats = default_amount
         zap_amounts = get_zap_amount_items(default_amount)
     }
 }
 
 /// Enables the user to enter a Bitcoin amount to be sent. Based on `CustomizeZapView`.
 struct LnurlAmountView: View {
     let damus_state: DamusState
     let lnurlString: String
     let onInvoiceFetched: (Invoice) -> Void
     let onCancel: () -> Void
     
     @StateObject var model: LnurlAmountModel = LnurlAmountModel()
     @Environment(\.colorScheme) var colorScheme
     @FocusState var isAmountFocused: Bool
     
     init(damus_state: DamusState, lnurlString: String, onInvoiceFetched: @escaping (Invoice) -> Void, onCancel: @escaping () -> Void) {
         self.damus_state = damus_state
         self.lnurlString = lnurlString
         self.onInvoiceFetched = onInvoiceFetched
         self.onCancel = onCancel
     }
     
     func AmountButton(zapAmountItem: ZapAmountItem) -> some View {
         let isSelected = model.custom_amount_sats == zapAmountItem.amount
         
         return Button(action: {
             model.custom_amount_sats = zapAmountItem.amount
             model.custom_amount = String(zapAmountItem.amount)
         }) {
             let fmt = format_msats_abbrev(Int64(zapAmountItem.amount) * 1000)
             Text(verbatim: "\(zapAmountItem.icon)\n\(fmt)")
                 .contentShape(Rectangle())
                 .font(.headline)
                 .frame(width: 70, height: 70)
                 .foregroundColor(DamusColors.adaptableBlack)
                 .background(isSelected ? DamusColors.adaptableWhite : DamusColors.adaptableGrey)
                 .cornerRadius(15)
                 .overlay(RoundedRectangle(cornerRadius: 15)
                     .stroke(DamusColors.purple.opacity(isSelected ? 1.0 : 0.0), lineWidth: 2))
         }
     }
     
     func amount_parts(_ n: Int) -> [ZapAmountItem] {
         var i: Int = -1
         let start = n * 4
         let end = start + 4
         
         return model.zap_amounts.filter { _ in
             i += 1
             return i >= start && i < end
         }
     }
     
     func AmountsPart(n: Int) -> some View {
         HStack(alignment: .center, spacing: 15) {
             ForEach(amount_parts(n)) { entry in
                 AmountButton(zapAmountItem: entry)
             }
         }
     }
     
     var AmountGrid: some View {
         VStack {
             AmountsPart(n: 0)
             
             AmountsPart(n: 1)
         }
         .padding(10)
     }
     
     var CustomAmountTextField: some View {
         VStack(alignment: .center, spacing: 0) {
             TextField("", text: $model.custom_amount)
                 .focused($isAmountFocused)
                 .task {
                     self.isAmountFocused = true
                 }
                 .font(.system(size: 72, weight: .heavy))
                 .minimumScaleFactor(0.01)
                 .keyboardType(.numberPad)
                 .multilineTextAlignment(.center)
                 .onChange(of: model.custom_amount) { newValue in
                     if let parsed = handle_string_amount(new_value: newValue) {
                         model.custom_amount = parsed.formatted()
                         model.custom_amount_sats = parsed
                     } else {
                         model.custom_amount = "0"
                         model.custom_amount_sats = nil
                     }
                 }
             let noun = pluralizedString(key: "sats", count: model.custom_amount_sats ?? 0)
             Text(noun)
                 .font(.system(size: 18, weight: .heavy))
         }
     }
     
     func fetchInvoice() {
         guard let amount = model.custom_amount_sats, amount > 0 else {
             model.error = NSLocalizedString("Please enter a valid amount", comment: "Error message when no valid amount is entered for LNURL payment")
             return
         }
         
         model.processing = true
         model.error = nil
         
         Task { @MainActor in
             // For LNURL payments without zaps, we use nil for zapreq and comment
             // We just need the invoice for payment
             let msats = Int64(amount) * 1000
             
             // First get the payment request from the LNURL
             guard let payreq = await fetch_static_payreq(lnurlString) else {
                 model.processing = false
                 model.error = NSLocalizedString("Error fetching LNURL payment information", comment: "Error message when LNURL fetch fails")
                 return
             }
             
             // Then fetch the invoice with the amount
             guard let invoiceStr = await fetch_zap_invoice(payreq, zapreq: nil, msats: msats, zap_type: .non_zap, comment: nil) else {
                 model.processing = false
                 model.error = NSLocalizedString("Error fetching lightning invoice", comment: "Error message when there was an error fetching a lightning invoice")
                 return
             }
             
             // Decode the invoice to validate it
             guard let invoice = decode_bolt11(invoiceStr) else {
                 model.processing = false
                 model.error = NSLocalizedString("Invalid lightning invoice received", comment: "Error message when the lightning invoice received from LNURL is invalid")
                 return
             }
             
             // All good, pass the invoice back to the parent view
             model.processing = false
             onInvoiceFetched(invoice)
         }
     }
     
     var PayButton: some View {
         VStack {
             if model.processing {
                 Text("Processing...", comment: "Text to indicate that the app is in the process of fetching an invoice.")
                     .padding()
                 ProgressView()
             } else {
                 Button(action: {
                     fetchInvoice()
                 }) {
                     HStack {
                         Text("Continue", comment: "Button to proceed with LNURL payment process.")
                             .font(.system(size: 20, weight: .bold))
                     }
                     .frame(minWidth: 300, maxWidth: .infinity, alignment: .center)
                 }
                 .buttonStyle(GradientButtonStyle())
                 .disabled(model.custom_amount_sats == 0 || model.custom_amount == "0")
                 .opacity(model.custom_amount_sats == 0 || model.custom_amount == "0" ? 0.5 : 1.0)
                 .padding(10)
             }
             
             if let error = model.error {
                 Text(error)
                     .foregroundColor(.red)
                     .padding()
             }
         }
     }
     
     var CancelButton: some View {
         Button(action: onCancel) {
             HStack {
                 Text("Cancel", comment: "Button to cancel the LNURL payment process.")
                     .font(.headline)
                     .padding()
             }
             .frame(minWidth: 300, maxWidth: .infinity, alignment: .center)
         }
         .buttonStyle(NeutralButtonStyle())
         .padding()
     }
     
     var body: some View {
         VStack(alignment: .center, spacing: 20) {
             ScrollView {
                 VStack {
                     Text("Enter Amount", comment: "Header text for LNURL payment amount entry screen")
                         .font(.title)
                         .fontWeight(.bold)
                         .padding()
                     
                     Text("How much would you like to send?", comment: "Instruction text for LNURL payment amount")
                         .font(.headline)
                         .multilineTextAlignment(.center)
                         .padding(.bottom)
                     
                     CustomAmountTextField
                     
                     AmountGrid
                     
                     PayButton
                     
                     CancelButton
                 }
             }
         }
         .onAppear {
             model.set_defaults(settings: damus_state.settings)
         }
         .onTapGesture {
             hideKeyboard()
         }
     }
 }
 
 struct LnurlAmountView_Previews: PreviewProvider {
     static var previews: some View {
         LnurlAmountView(
             damus_state: test_damus_state,
             lnurlString: "lnurl1dp68gurn8ghj7um9wfmxjcm99e3k7mf0v9cxj0m385ekvcenxc6r2c35xvukxefcv5mkvv34x5ekzd3ev56nyd3hxqurzepexejxxepnxscrvwfnv9nxzcn9xq6xyefhvgcxxcmyxymnserxfq5fns",
             onInvoiceFetched: { _ in },
             onCancel: {}
         )
         .frame(width: 400, height: 600)
     }
 }