341 lines
11 KiB
Swift
341 lines
11 KiB
Swift
//
|
|
// SendViewController.swift
|
|
// ZcashLightClientSample
|
|
//
|
|
// Created by Francisco Gindre on 12/3/19.
|
|
// Copyright © 2019 Electric Coin Company. All rights reserved.
|
|
//
|
|
|
|
import Combine
|
|
import UIKit
|
|
import ZcashLightClientKit
|
|
import KRProgressHUD
|
|
|
|
class SendViewController: UIViewController {
|
|
@IBOutlet weak var addressLabel: UILabel!
|
|
@IBOutlet weak var amountLabel: UILabel!
|
|
@IBOutlet weak var addressTextField: UITextField!
|
|
@IBOutlet weak var amountTextField: UITextField!
|
|
@IBOutlet weak var balanceLabel: UILabel!
|
|
@IBOutlet weak var verifiedBalanceLabel: UILabel!
|
|
@IBOutlet weak var maxFunds: UISwitch!
|
|
@IBOutlet weak var sendButton: UIButton!
|
|
@IBOutlet weak var synchronizerStatusLabel: UILabel!
|
|
@IBOutlet weak var memoField: UITextView!
|
|
@IBOutlet weak var charactersLeftLabel: UILabel!
|
|
|
|
let characterLimit: Int = 512
|
|
|
|
var wallet = Initializer.shared
|
|
|
|
// swiftlint:disable:next implicitly_unwrapped_optional
|
|
var synchronizer: Synchronizer!
|
|
// swiftlint:disable:next implicitly_unwrapped_optional
|
|
var closureSynchronizer: ClosureSynchronizer!
|
|
|
|
var cancellables: [AnyCancellable] = []
|
|
|
|
override func viewDidLoad() {
|
|
super.viewDidLoad()
|
|
synchronizer = AppDelegate.shared.sharedSynchronizer
|
|
closureSynchronizer = ClosureSDKSynchronizer(synchronizer: AppDelegate.shared.sharedSynchronizer)
|
|
let tapRecognizer = UITapGestureRecognizer(target: self, action: #selector(viewTapped(_:)))
|
|
self.view.addGestureRecognizer(tapRecognizer)
|
|
setUp()
|
|
|
|
closureSynchronizer.prepare(
|
|
with: DemoAppConfig.defaultSeed,
|
|
walletBirthday: DemoAppConfig.defaultBirthdayHeight,
|
|
for: .existingWallet
|
|
) { result in
|
|
loggerProxy.debug("Prepare result: \(result)")
|
|
}
|
|
}
|
|
|
|
override func viewDidAppear(_ animated: Bool) {
|
|
super.viewDidAppear(animated)
|
|
closureSynchronizer.start(retry: false) { [weak self] error in
|
|
DispatchQueue.main.async {
|
|
guard let self else { return }
|
|
self.synchronizerStatusLabel.text = SDKSynchronizer.textFor(state: self.synchronizer.latestState.syncStatus)
|
|
|
|
if let error {
|
|
self.fail(error)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@objc func viewTapped(_ recognizer: UITapGestureRecognizer) {
|
|
let point = recognizer.location(in: self.view)
|
|
if addressTextField.isFirstResponder && !addressTextField.frame.contains(point) {
|
|
addressTextField.resignFirstResponder()
|
|
} else if amountTextField.isFirstResponder && !amountTextField.frame.contains(point) {
|
|
amountTextField.resignFirstResponder()
|
|
} else if memoField.isFirstResponder &&
|
|
!memoField.frame.contains(point) {
|
|
memoField.resignFirstResponder()
|
|
}
|
|
}
|
|
|
|
func setUp() {
|
|
Task { @MainActor in
|
|
await updateBalance()
|
|
await toggleSendButton()
|
|
}
|
|
memoField.text = ""
|
|
memoField.layer.borderColor = UIColor.gray.cgColor
|
|
memoField.layer.borderWidth = 1
|
|
memoField.layer.cornerRadius = 5
|
|
charactersLeftLabel.text = textForCharacterCount(0)
|
|
|
|
synchronizer.stateStream
|
|
.throttle(for: .seconds(0.2), scheduler: DispatchQueue.main, latest: true)
|
|
.sink(
|
|
receiveValue: { [weak self] state in
|
|
Task { @MainActor in
|
|
await self?.updateBalance()
|
|
}
|
|
self?.synchronizerStatusLabel.text = SDKSynchronizer.textFor(state: state.syncStatus)
|
|
}
|
|
)
|
|
.store(in: &cancellables)
|
|
}
|
|
|
|
func updateBalance() async {
|
|
balanceLabel.text = format(balance: (try? await synchronizer.getAccountBalance(accountIndex: 0))?.saplingBalance.total() ?? .zero)
|
|
verifiedBalanceLabel.text = format(balance: (try? await synchronizer.getAccountBalance(accountIndex: 0))?.saplingBalance.spendableValue ?? .zero)
|
|
}
|
|
|
|
func format(balance: Zatoshi = Zatoshi()) -> String {
|
|
"Zec \(balance.formattedString ?? "0.0")"
|
|
}
|
|
|
|
func toggleSendButton() async {
|
|
sendButton.isEnabled = await isFormValid()
|
|
}
|
|
|
|
func maxFundsOn() {
|
|
Task { @MainActor in
|
|
let fee = Zatoshi(10000)
|
|
let max: Zatoshi = ((try? await synchronizer.getAccountBalance(accountIndex: 0))?.saplingBalance.spendableValue ?? .zero) - fee
|
|
amountTextField.text = format(balance: max)
|
|
amountTextField.isEnabled = false
|
|
}
|
|
}
|
|
|
|
func maxFundsOff() {
|
|
amountTextField.isEnabled = true
|
|
}
|
|
|
|
func isFormValid() async -> Bool {
|
|
switch synchronizer.latestState.syncStatus {
|
|
case .upToDate:
|
|
let isBalanceValid = await self.isBalanceValid()
|
|
let isAmountValid = await self.isAmountValid()
|
|
return isBalanceValid && isAmountValid && isRecipientValid()
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func isBalanceValid() async -> Bool {
|
|
let balance = (try? await synchronizer.getAccountBalance(accountIndex: 0))?.saplingBalance.spendableValue ?? .zero
|
|
return balance > .zero
|
|
}
|
|
|
|
func isAmountValid() async -> Bool {
|
|
let balance = (try? await synchronizer.getAccountBalance(accountIndex: 0))?.saplingBalance.spendableValue ?? .zero
|
|
guard
|
|
let value = amountTextField.text,
|
|
let amount = NumberFormatter.zcashNumberFormatter.number(from: value).flatMap({ Zatoshi($0.int64Value) }),
|
|
amount <= balance
|
|
else {
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
func isRecipientValid() -> Bool {
|
|
guard let addr = self.addressTextField.text else {
|
|
return false
|
|
}
|
|
return wallet.isValidSaplingAddress(addr) || wallet.isValidTransparentAddress(addr)
|
|
}
|
|
|
|
@IBAction func maxFundsValueChanged(_ sender: Any) {
|
|
if maxFunds.isOn {
|
|
maxFundsOn()
|
|
} else {
|
|
maxFundsOff()
|
|
}
|
|
}
|
|
|
|
@IBAction func send(_ sender: Any) {
|
|
Task { @MainActor in
|
|
guard await isFormValid() else {
|
|
loggerProxy.warn("WARNING: Form is invalid")
|
|
return
|
|
}
|
|
|
|
let alert = UIAlertController(
|
|
title: "About To send funds!",
|
|
message: """
|
|
This is an ugly confirmation message. You should come up with something fancier that lets the user be sure about sending funds without \
|
|
disturbing the user experience with an annoying alert like this one
|
|
""",
|
|
preferredStyle: UIAlertController.Style.alert
|
|
)
|
|
|
|
let sendAction = UIAlertAction(
|
|
title: "Send!",
|
|
style: UIAlertAction.Style.default,
|
|
handler: { _ in
|
|
self.send()
|
|
}
|
|
)
|
|
|
|
let cancelAction = UIAlertAction(
|
|
title: "Go back! I'm not sure about this.",
|
|
style: UIAlertAction.Style.destructive,
|
|
handler: { _ in
|
|
self.cancel()
|
|
}
|
|
)
|
|
|
|
alert.addAction(sendAction)
|
|
alert.addAction(cancelAction)
|
|
|
|
self.present(alert, animated: true, completion: nil)
|
|
}
|
|
}
|
|
|
|
func send() {
|
|
Task { @MainActor in
|
|
guard
|
|
await isFormValid(),
|
|
let amount = amountTextField.text,
|
|
let zec = NumberFormatter.zcashNumberFormatter.number(from: amount).flatMap({ Zatoshi($0.int64Value) }),
|
|
let recipient = addressTextField.text
|
|
else {
|
|
loggerProxy.warn("WARNING: Form is invalid")
|
|
return
|
|
}
|
|
|
|
let derivationTool = DerivationTool(networkType: kZcashNetwork.networkType)
|
|
guard let spendingKey = try? derivationTool.deriveUnifiedSpendingKey(seed: DemoAppConfig.defaultSeed, accountIndex: 0) else {
|
|
loggerProxy.error("NO SPENDING KEY")
|
|
return
|
|
}
|
|
|
|
KRProgressHUD.show()
|
|
|
|
do {
|
|
let pendingTransaction = try await synchronizer.sendToAddress(
|
|
spendingKey: spendingKey,
|
|
zatoshi: zec,
|
|
// swiftlint:disable:next force_try
|
|
toAddress: try! Recipient(recipient, network: kZcashNetwork.networkType),
|
|
// swiftlint:disable:next force_try
|
|
memo: try! self.memoField.text.asMemo()
|
|
)
|
|
KRProgressHUD.dismiss()
|
|
loggerProxy.info("transaction created: \(pendingTransaction)")
|
|
} catch {
|
|
fail(error)
|
|
loggerProxy.error("SEND FAILED: \(error)")
|
|
}
|
|
}
|
|
}
|
|
|
|
func fail(_ error: Error) {
|
|
let alert = UIAlertController(
|
|
title: "Send failed!",
|
|
message: "\(error)",
|
|
preferredStyle: UIAlertController.Style.alert
|
|
)
|
|
|
|
let action = UIAlertAction(title: "OK :(", style: UIAlertAction.Style.default, handler: nil)
|
|
alert.addAction(action)
|
|
self.present(alert, animated: true, completion: nil)
|
|
}
|
|
|
|
func cancel() {}
|
|
|
|
func textForCharacterCount(_ count: Int) -> String {
|
|
"\(count) of \(characterLimit) bytes left"
|
|
}
|
|
}
|
|
|
|
extension SendViewController: UITextFieldDelegate {
|
|
func textFieldShouldBeginEditing(_ textField: UITextField) -> Bool {
|
|
if textField == amountTextField {
|
|
return !maxFunds.isOn
|
|
}
|
|
return true
|
|
}
|
|
|
|
func textFieldDidEndEditing(_ textField: UITextField) {
|
|
textField.resignFirstResponder()
|
|
Task { @MainActor in
|
|
await toggleSendButton()
|
|
}
|
|
}
|
|
|
|
func textFieldShouldReturn(_ textField: UITextField) -> Bool {
|
|
if textField == amountTextField {
|
|
addressTextField.becomeFirstResponder()
|
|
return false
|
|
}
|
|
textField.resignFirstResponder()
|
|
return true
|
|
}
|
|
}
|
|
|
|
extension SendViewController: UITextViewDelegate {
|
|
func textView(_ textView: UITextView, shouldChangeTextIn range: NSRange, replacementText text: String) -> Bool {
|
|
let userPressedDelete = text.isEmpty && range.length > 0
|
|
return textView.text.utf8.count < characterLimit || userPressedDelete
|
|
}
|
|
|
|
func textViewDidChange(_ textView: UITextView) {
|
|
self.charactersLeftLabel.text = textForCharacterCount(textView.text.utf8.count)
|
|
}
|
|
}
|
|
|
|
extension SDKSynchronizer {
|
|
static func textFor(state: SyncStatus) -> String {
|
|
switch state {
|
|
case .syncing(let progress):
|
|
return "Syncing \(progress * 100.0)%"
|
|
|
|
case .upToDate:
|
|
return "Up to Date 😎"
|
|
|
|
case .unprepared:
|
|
return "Unprepared 😅"
|
|
|
|
case .stopped:
|
|
return "Stopped"
|
|
|
|
case .error(ZcashError.synchronizerDisconnected):
|
|
return "disconnected 💔"
|
|
|
|
case .error(let error):
|
|
return "Error: \(error)"
|
|
}
|
|
}
|
|
}
|
|
|
|
extension Optional where Wrapped == String {
|
|
func asMemo() throws -> Memo {
|
|
switch self {
|
|
case .some(let string):
|
|
return try Memo(string: string)
|
|
case .none:
|
|
return .empty
|
|
}
|
|
}
|
|
}
|