Path: blob/main/SignalUI/Payments/MobileCoinAPI.swift
1 views
//
// Copyright 2021 Signal Messenger, LLC
// SPDX-License-Identifier: AGPL-3.0-only
//
import Foundation
import MobileCoin
public import SignalServiceKit
public class MobileCoinAPI {
// MARK: - Passphrases & Entropy
public static func passphrase(forPaymentsEntropy paymentsEntropy: Data) throws -> PaymentsPassphrase {
guard paymentsEntropy.count == PaymentsConstants.paymentsEntropyLength else {
throw PaymentsError.invalidEntropy
}
let result = MobileCoin.Mnemonic.mnemonic(fromEntropy: paymentsEntropy)
switch result {
case .success(let mnemonic):
return try PaymentsPassphrase.parse(
passphrase: mnemonic,
validateWords: false,
)
case .failure(let error):
owsFailDebug("Error: \(error)")
let error = Self.convertMCError(error: error)
throw error
}
}
public static func paymentsEntropy(forPassphrase passphrase: PaymentsPassphrase) throws -> Data {
let mnemonic = passphrase.asPassphrase
let result = MobileCoin.Mnemonic.entropy(fromMnemonic: mnemonic)
switch result {
case .success(let paymentsEntropy):
guard paymentsEntropy.count == PaymentsConstants.paymentsEntropyLength else {
throw PaymentsError.invalidEntropy
}
return paymentsEntropy
case .failure(let error):
owsFailDebug("Error: \(error)")
let error = Self.convertMCError(error: error)
throw error
}
}
public static func isValidPassphraseWord(_ word: String?) -> Bool {
guard let word = word?.strippedOrNil else {
return false
}
return !MobileCoin.Mnemonic.words(matchingPrefix: word).isEmpty
}
// MARK: -
private let paymentsEntropy: Data
// PAYMENTS TODO: Finalize this value with the designers.
private static let timeoutDuration: TimeInterval = 60
let localAccount: MobileCoinAccount
private let client: MobileCoinClient
private init(
paymentsEntropy: Data,
localAccount: MobileCoinAccount,
client: MobileCoinClient,
) throws {
guard paymentsEntropy.count == PaymentsConstants.paymentsEntropyLength else {
throw PaymentsError.invalidEntropy
}
owsAssertDebug(SSKEnvironment.shared.paymentsHelperRef.arePaymentsEnabled)
self.paymentsEntropy = paymentsEntropy
self.localAccount = localAccount
self.client = client
}
// MARK: -
public static func configureSDKLogging() {
if
DebugFlags.internalLogging,
!CurrentAppContext().isRunningTests
{
MobileCoinLogging.logSensitiveData = true
}
}
// MARK: -
private func withTimeoutAndErrorConversion<T>(makeRequest: @escaping () async throws -> T) async throws -> T {
do {
return try await withUncooperativeTimeout(seconds: Self.timeoutDuration) {
do {
return try await makeRequest()
} catch {
let convertedError = Self.convertMCError(error: error)
owsFailDebugUnlessMCNetworkFailure(convertedError)
throw convertedError
}
}
} catch is UncooperativeTimeoutError {
throw PaymentsError.timeout
}
}
// MARK: -
static func buildLocalAccount(paymentsEntropy: Data) throws -> MobileCoinAccount {
try Self.buildAccount(forPaymentsEntropy: paymentsEntropy)
}
private static func parseAuthorizationResponse(params: ParamParser) throws -> OWSAuthorization {
let username: String = try params.required(key: "username")
let password: String = try params.required(key: "password")
return OWSAuthorization(username: username, password: password)
}
public static func build(paymentsEntropy: Data) async throws -> MobileCoinAPI {
guard !CurrentAppContext().isNSE else {
throw OWSAssertionError("Payments disabled in NSE.")
}
let request = OWSRequestFactory.paymentsAuthenticationCredentialRequest()
let response = try await SSKEnvironment.shared.networkManagerRef.asyncRequest(request)
guard let params = response.responseBodyParamParser else {
throw OWSAssertionError("Missing or invalid JSON")
}
let signalAuthorization = try Self.parseAuthorizationResponse(params: params)
let localAccount = try Self.buildAccount(forPaymentsEntropy: paymentsEntropy)
let client = try localAccount.buildClient(signalAuthorization: signalAuthorization)
return try MobileCoinAPI(paymentsEntropy: paymentsEntropy, localAccount: localAccount, client: client)
}
// MARK: -
class func isValidMobileCoinPublicAddress(_ publicAddressData: Data) -> Bool {
MobileCoin.PublicAddress(serializedData: publicAddressData) != nil
}
// MARK: -
func getLocalBalance() -> Promise<TSPaymentAmount> {
Logger.verbose("")
let client = self.client
return firstly(on: DispatchQueue.global()) { () throws -> Promise<MobileCoin.Balance> in
let (promise, future) = Promise<MobileCoin.Balance>.pending()
client.updateBalances { (result: Swift.Result<Balances, BalanceUpdateError>) in
switch result {
case .success(let balances):
future.resolve(balances.mobBalance)
case .failure(let error):
let error = Self.convertMCError(error: error)
future.reject(error)
}
}
return promise
}.map(on: DispatchQueue.global()) { (balance: MobileCoin.Balance) -> TSPaymentAmount in
Logger.verbose("Success: \(balance)")
// We do not need to support amountPicoMobHigh.
guard let amountPicoMob = balance.amount() else {
throw OWSAssertionError("Invalid balance.")
}
return TSPaymentAmount(currency: .mobileCoin, picoMob: amountPicoMob)
}.recover(on: DispatchQueue.global()) { (error: Error) -> Promise<TSPaymentAmount> in
owsFailDebugUnlessMCNetworkFailure(error)
throw error
}.timeout(seconds: Self.timeoutDuration, description: "getLocalBalance") { () -> Error in
PaymentsError.timeout
}
}
func getEstimatedFee(forPaymentAmount paymentAmount: TSPaymentAmount) async throws -> TSPaymentAmount {
guard paymentAmount.isValidAmount(canBeEmpty: false) else {
throw OWSAssertionError("Invalid amount.")
}
return try await _getPaymentAmount(canBeEmpty: false, getPicoMob: { [client] in
return try await withCheckedThrowingContinuation { continuation in
// We don't need to support amountPicoMobHigh.
let amount = Amount(paymentAmount.picoMob, in: .MOB)
client.estimateTotalFee(toSendAmount: amount, feeLevel: Self.feeLevel) {
continuation.resume(with: $0)
}
}
})
}
func maxTransactionAmount() async throws -> TSPaymentAmount {
return try await _getPaymentAmount(canBeEmpty: true, getPicoMob: { [client] in
return try await withCheckedThrowingContinuation { continuation in
client.amountTransferable(tokenId: .MOB, feeLevel: Self.feeLevel) {
continuation.resume(with: $0)
}
}
})
}
private func _getPaymentAmount(canBeEmpty: Bool, getPicoMob: @escaping () async throws -> UInt64) async throws -> TSPaymentAmount {
let picoMob = try await withTimeoutAndErrorConversion(makeRequest: getPicoMob)
let result = TSPaymentAmount(currency: .mobileCoin, picoMob: picoMob)
guard result.isValidAmount(canBeEmpty: canBeEmpty) else {
throw OWSAssertionError("Invalid amount.")
}
return result
}
struct PreparedTransaction: PreparedPayment {
let transaction: MobileCoin.Transaction
let receipt: MobileCoin.Receipt
let feeAmount: TSPaymentAmount
}
func prepareTransaction(
paymentAmount: TSPaymentAmount,
recipientPublicAddress: MobileCoin.PublicAddress,
shouldUpdateBalance: Bool,
) -> Promise<PreparedTransaction> {
Logger.verbose("")
Logger.verbose("paymentAmount: \(paymentAmount.picoMob)")
let client = self.client
return firstly(on: DispatchQueue.global()) { () throws -> Promise<Void> in
guard shouldUpdateBalance else {
return Promise.value(())
}
return firstly(on: DispatchQueue.global()) { () throws -> Promise<TSPaymentAmount> in
// prepareTransaction() will fail if local balance is not yet known.
self.getLocalBalance()
}.done(on: DispatchQueue.global()) { (balance: TSPaymentAmount) in
Logger.verbose("balance: \(balance.picoMob)")
}
}.then(on: DispatchQueue.global()) { () -> Promise<TSPaymentAmount> in
return Promise.wrapAsync {
try await self.getEstimatedFee(forPaymentAmount: paymentAmount)
}
}.then(on: DispatchQueue.global()) { (estimatedFeeAmount: TSPaymentAmount) -> Promise<PreparedTransaction> in
Logger.verbose("estimatedFeeAmount: \(estimatedFeeAmount.picoMob)")
guard paymentAmount.isValidAmount(canBeEmpty: false) else {
throw OWSAssertionError("Invalid amount.")
}
guard estimatedFeeAmount.isValidAmount(canBeEmpty: false) else {
throw OWSAssertionError("Invalid fee.")
}
let (promise, future) = Promise<PreparedTransaction>.pending()
// We don't need to support amountPicoMobHigh.
client.prepareTransaction(
to: recipientPublicAddress,
amount: Amount(paymentAmount.picoMob, in: .MOB),
fee: estimatedFeeAmount.picoMob,
) { (result: Swift.Result<
PendingSinglePayloadTransaction,
TransactionPreparationError,
>) in
switch result {
case .success(let payload):
let transaction = payload.transaction
let receipt = payload.receipt
let finalFeeAmount = TSPaymentAmount(
currency: .mobileCoin,
picoMob: transaction.fee,
)
owsAssertDebug(estimatedFeeAmount == finalFeeAmount)
let preparedTransaction = PreparedTransaction(
transaction: transaction,
receipt: receipt,
feeAmount: finalFeeAmount,
)
future.resolve(preparedTransaction)
case .failure(let error):
let error = Self.convertMCError(error: error)
future.reject(error)
}
}
return promise
}.recover(on: DispatchQueue.global()) { (error: Error) -> Promise<PreparedTransaction> in
owsFailDebugUnlessMCNetworkFailure(error)
throw error
}.timeout(seconds: Self.timeoutDuration, description: "prepareTransaction") { () -> Error in
PaymentsError.timeout
}
}
// TODO: Are we always going to use _minimum_ fee?
private static let feeLevel: MobileCoin.FeeLevel = .minimum
func requiresDefragmentation(forPaymentAmount paymentAmount: TSPaymentAmount) -> Promise<Bool> {
Logger.verbose("")
let client = self.client
return firstly(on: DispatchQueue.global()) { () -> Promise<Bool> in
let (promise, future) = Promise<Bool>.pending()
client.requiresDefragmentation(
toSendAmount: Amount(paymentAmount.picoMob, in: .MOB),
feeLevel: Self.feeLevel,
) { (result: Swift.Result<
Bool,
TransactionEstimationFetcherError,
>) in
switch result {
case .success(let shouldDefragment):
future.resolve(shouldDefragment)
case .failure(let error):
let error = Self.convertMCError(error: error)
future.reject(error)
}
}
return promise
}.recover(on: DispatchQueue.global()) { (error: Error) -> Promise<Bool> in
owsFailDebugUnlessMCNetworkFailure(error)
throw error
}.timeout(seconds: Self.timeoutDuration, description: "requiresDefragmentation") { () -> Error in
PaymentsError.timeout
}
}
func prepareDefragmentationStepTransactions(forPaymentAmount paymentAmount: TSPaymentAmount) -> Promise<[MobileCoin.Transaction]> {
Logger.verbose("")
let client = self.client
return firstly(on: DispatchQueue.global()) { () throws -> Promise<[MobileCoin.Transaction]> in
let (promise, future) = Promise<[MobileCoin.Transaction]>.pending()
client.prepareDefragmentationStepTransactions(
toSendAmount: Amount(paymentAmount.picoMob, in: .MOB),
feeLevel: Self.feeLevel,
) { (result: Swift.Result<
[MobileCoin.Transaction],
MobileCoin.DefragTransactionPreparationError,
>) in
switch result {
case .success(let transactions):
future.resolve(transactions)
case .failure(let error):
let error = Self.convertMCError(error: error)
future.reject(error)
}
}
return promise
}.timeout(seconds: Self.timeoutDuration, description: "prepareDefragmentationStepTransactions") { () -> Error in
PaymentsError.timeout
}
}
func submitTransaction(transaction: MobileCoin.Transaction) async throws -> Void {
Logger.verbose("")
return try await withTimeoutAndErrorConversion { [client] in
return try await withCheckedThrowingContinuation { continuation in
client.submitTransaction(transaction: transaction) { (result: Result<UInt64, SubmitTransactionError>) in
switch result {
case .success:
Logger.verbose("Success.")
continuation.resume(returning: ())
case .failure(let error):
continuation.resume(throwing: error.submissionError)
}
}
}
}
}
func getOutgoingTransactionStatus(transaction: MobileCoin.Transaction) async throws -> MCOutgoingTransactionStatus {
Logger.verbose("")
let transactionStatus = try await withTimeoutAndErrorConversion { [client] in
return try await withCheckedThrowingContinuation { continuation in
client.txOutStatus(of: transaction) { (result: Swift.Result<MobileCoin.TransactionStatus, ConnectionError>) in
continuation.resume(with: result)
}
}
}
let outgoingTransactionStatus = MCOutgoingTransactionStatus(transactionStatus: transactionStatus)
Logger.verbose("Success: \(outgoingTransactionStatus)")
SUIEnvironment.shared.paymentsSwiftRef.clearCurrentPaymentBalance()
return outgoingTransactionStatus
}
func paymentAmount(forReceipt receipt: MobileCoin.Receipt) throws -> TSPaymentAmount {
try Self.paymentAmount(forReceipt: receipt, localAccount: localAccount)
}
static func paymentAmount(
forReceipt receipt: MobileCoin.Receipt,
localAccount: MobileCoinAccount,
) throws -> TSPaymentAmount {
guard let picoMob = receipt.validateAndUnmaskValue(accountKey: localAccount.accountKey) else {
// This can happen if the receipt was address to a different account.
owsFailDebug("Receipt missing amount.")
throw PaymentsError.invalidAmount
}
guard picoMob > 0 else {
owsFailDebug("Receipt has invalid amount.")
throw PaymentsError.invalidAmount
}
return TSPaymentAmount(currency: .mobileCoin, picoMob: picoMob)
}
func getIncomingReceiptStatus(receipt: MobileCoin.Receipt) -> Promise<MCIncomingReceiptStatus> {
Logger.verbose("")
let client = self.client
let localAccount = self.localAccount
return firstly(on: DispatchQueue.global()) { () throws -> Promise<TSPaymentAmount> in
// .status(of: receipt) requires an updated balance.
//
// TODO: We could improve perf when verifying multiple receipts by getting balance just once.
self.getLocalBalance()
}.map(on: DispatchQueue.global()) { (_: TSPaymentAmount) -> MCIncomingReceiptStatus in
let paymentAmount: TSPaymentAmount
do {
paymentAmount = try Self.paymentAmount(
forReceipt: receipt,
localAccount: localAccount,
)
} catch {
owsFailDebug("Error: \(error)")
return MCIncomingReceiptStatus(
receiptStatus: .failed,
paymentAmount: .zeroMob,
txOutPublicKey: Data(),
)
}
let txOutPublicKey: Data = receipt.txOutPublicKey
let result = client.status(of: receipt)
switch result {
case .success(let receiptStatus):
return MCIncomingReceiptStatus(
receiptStatus: receiptStatus,
paymentAmount: paymentAmount,
txOutPublicKey: txOutPublicKey,
)
case .failure(let error):
let error = Self.convertMCError(error: error)
throw error
}
}.map(on: DispatchQueue.global()) { (value: MCIncomingReceiptStatus) -> MCIncomingReceiptStatus in
Logger.verbose("Success: \(value)")
return value
}.recover(on: DispatchQueue.global()) { (error: Error) -> Promise<MCIncomingReceiptStatus> in
owsFailDebugUnlessMCNetworkFailure(error)
throw error
}.timeout(seconds: Self.timeoutDuration, description: "getIncomingReceiptStatus") { () -> Error in
PaymentsError.timeout
}
}
func getAccountActivity() async throws -> MobileCoin.AccountActivity {
Logger.verbose("")
let client = self.client
_ = try await withTimeoutAndErrorConversion {
return try await withCheckedThrowingContinuation { continuation in
client.updateBalances { (result: Swift.Result<Balances, BalanceUpdateError>) in
continuation.resume(with: result)
}
}
}
let accountActivity = client.accountActivity(for: .MOB)
Logger.verbose("Success: \(accountActivity.blockCount)")
return accountActivity
}
}
// MARK: -
extension MobileCoin.PublicAddress {
var asPaymentAddress: TSPaymentAddress {
return TSPaymentAddress(
currency: .mobileCoin,
mobileCoinPublicAddressData: serializedData,
)
}
}
// MARK: -
extension TSPaymentAddress {
func asPublicAddress() throws -> MobileCoin.PublicAddress {
guard currency == .mobileCoin else {
throw PaymentsError.invalidCurrency
}
guard let address = MobileCoin.PublicAddress(serializedData: mobileCoinPublicAddressData) else {
throw OWSAssertionError("Invalid mobileCoinPublicAddressData.")
}
return address
}
}
// MARK: -
struct MCIncomingReceiptStatus {
let receiptStatus: MobileCoin.ReceiptStatus
let paymentAmount: TSPaymentAmount
let txOutPublicKey: Data
}
// MARK: -
struct MCOutgoingTransactionStatus {
let transactionStatus: MobileCoin.TransactionStatus
}
// MARK: - Error Handling
extension MobileCoinAPI {
public static func convertMCError(error: Error) -> PaymentsError {
func switchOnConnectionError(_ error: MobileCoin.ConnectionError) -> PaymentsError {
switch error {
case .connectionFailure(let reason):
Logger.warn("Error: \(error), reason: \(reason)")
return PaymentsError.connectionFailure
case .authorizationFailure(let reason):
owsFailDebug("Error: \(error), reason: \(reason)")
// Immediately discard the SDK client instance; the auth token may be stale.
SUIEnvironment.shared.paymentsRef.didReceiveMCAuthError()
return PaymentsError.authorizationFailure
case .invalidServerResponse(let reason):
// TODO: It would be preferable to owsFailDebug()
// here. Ledger errors can now occur during
// fee transitions, but should be very rare.
Logger.warn("Error: \(error), reason: \(reason)")
return PaymentsError.invalidServerResponse
case .attestationVerificationFailed(let reason):
owsFailDebug("Error: \(error), reason: \(reason)")
return PaymentsError.attestationVerificationFailed
case .outdatedClient(let reason):
owsFailDebug("Error: \(error), reason: \(reason)")
return PaymentsError.outdatedClient
case .serverRateLimited(let reason):
owsFailDebug("Error: \(error), reason: \(reason)")
return PaymentsError.serverRateLimited
}
}
switch error {
case let error as MobileCoin.SecurityError:
// Wraps errors from Apple Security framework used in SecSSLCertificate init.
owsFailDebug("Error: \(error)")
return PaymentsError.invalidInput
case let error as MobileCoin.InvalidInputError:
owsFailDebug("Error: \(error)")
return PaymentsError.invalidInput
case let error as MobileCoin.BalanceUpdateError:
switch error {
case .connectionError(let error):
return switchOnConnectionError(error)
case .fogSyncError(let error):
Logger.warn("Error: \(error)")
return PaymentsError.fogOutOfSync
}
case let error as MobileCoin.ConnectionError:
return switchOnConnectionError(error)
case let error as MobileCoin.TransactionPreparationError:
switch error {
case .invalidInput(let reason):
owsFailDebug("Error: \(error), reason: \(reason)")
return PaymentsError.invalidInput
case .insufficientBalance:
Logger.warn("Error: \(error)")
return PaymentsError.insufficientFunds
case .defragmentationRequired:
Logger.warn("Error: \(error)")
return PaymentsError.defragmentationRequired
case .connectionError(let connectionError):
// Recurse.
return convertMCError(error: connectionError)
}
case let error as MobileCoin.TransactionSubmissionError:
switch error {
case .connectionError(let connectionError):
// Recurse.
return convertMCError(error: connectionError)
case .invalidTransaction:
Logger.warn("Error: \(error)")
return PaymentsError.invalidTransaction
case .feeError:
Logger.warn("Error: \(error)")
return PaymentsError.invalidFee
case .tombstoneBlockTooFar:
Logger.warn("Error: \(error)")
// Map to .invalidTransaction
return PaymentsError.invalidTransaction
case .inputsAlreadySpent:
Logger.warn("Error: \(error)")
return PaymentsError.inputsAlreadySpent
case .missingMemo:
Logger.warn("Error: \(error)")
return PaymentsError.missingMemo
case .outputAlreadyExists:
// Transaction with same public key already exists (idempotence)
Logger.warn("Error: \(error)")
return PaymentsError.invalidTransaction
}
case let error as MobileCoin.DefragTransactionPreparationError:
switch error {
case .invalidInput(let reason):
owsFailDebug("Error: \(error), reason: \(reason)")
return PaymentsError.invalidInput
case .insufficientBalance:
Logger.warn("Error: \(error)")
return PaymentsError.insufficientFunds
case .connectionError(let connectionError):
// Recurse.
return convertMCError(error: connectionError)
}
case let error as MobileCoin.BalanceTransferEstimationFetcherError:
switch error {
case .feeExceedsBalance:
// TODO: Review this mapping.
Logger.warn("Error: \(error)")
return PaymentsError.insufficientFunds
case .balanceOverflow:
// TODO: Review this mapping.
Logger.warn("Error: \(error)")
return PaymentsError.insufficientFunds
case .connectionError(let connectionError):
// Recurse.
return convertMCError(error: connectionError)
}
case let error as MobileCoin.TransactionEstimationFetcherError:
switch error {
case .invalidInput(let reason):
owsFailDebug("Error: \(error), reason: \(reason)")
return PaymentsError.invalidInput
case .insufficientBalance:
Logger.warn("Error: \(error)")
return PaymentsError.insufficientFunds
case .connectionError(let connectionError):
// Recurse.
return convertMCError(error: connectionError)
}
default:
owsFailDebug("Unexpected error: \(error)")
return PaymentsError.unknownSDKError
}
}
}
// MARK: -
public extension PaymentsError {
var isPaymentsNetworkFailure: Bool {
switch self {
case .notEnabled,
.userNotRegisteredOrAppNotReady,
.userHasNoPublicAddress,
.invalidCurrency,
.invalidWalletKey,
.invalidAmount,
.invalidFee,
.insufficientFunds,
.invalidModel,
.tooOldToSubmit,
.indeterminateState,
.unknownSDKError,
.invalidInput,
.authorizationFailure,
.invalidServerResponse,
.attestationVerificationFailed,
.outdatedClient,
.serverRateLimited,
.serializationError,
.verificationStatusUnknown,
.ledgerBlockTimestampUnknown,
.missingModel,
.defragmentationRequired,
.invalidTransaction,
.inputsAlreadySpent,
.defragmentationFailed,
.invalidPassphrase,
.invalidEntropy,
.missingMemo,
.killSwitch:
return false
case .connectionFailure,
.fogOutOfSync,
.timeout,
.outgoingVerificationTakingTooLong:
return true
}
}
var isExpectedFromSDK: Bool {
switch self {
case .notEnabled,
.userNotRegisteredOrAppNotReady,
.userHasNoPublicAddress,
.invalidCurrency,
.invalidWalletKey,
.invalidAmount,
.invalidFee,
.invalidModel,
.indeterminateState,
.unknownSDKError,
.invalidInput,
.authorizationFailure,
.invalidServerResponse,
.attestationVerificationFailed,
.outdatedClient,
.serverRateLimited,
.serializationError,
.verificationStatusUnknown,
.ledgerBlockTimestampUnknown,
.missingModel,
.defragmentationRequired,
.invalidTransaction,
.inputsAlreadySpent,
.defragmentationFailed,
.invalidPassphrase,
.invalidEntropy,
.killSwitch,
.connectionFailure,
.timeout,
.outgoingVerificationTakingTooLong,
.fogOutOfSync,
.missingMemo:
return false
case .tooOldToSubmit,
.insufficientFunds:
return true
}
}
}
// MARK: -
// A variant of owsFailDebugUnlessNetworkFailure() that can handle
// network failures from the MobileCoin SDK.
@inlinable
public func owsFailDebugUnlessMCNetworkFailure(
_ error: Error,
file: String = #file,
function: String = #function,
line: Int = #line,
) {
if let paymentsError = error as? PaymentsError {
if paymentsError.isPaymentsNetworkFailure {
// Log but otherwise ignore network failures.
Logger.warn("Error: \(error)", file: file, function: function, line: line)
} else if paymentsError.isExpectedFromSDK {
Logger.warn("Error: \(error)", file: file, function: function, line: line)
} else {
owsFailDebug("Error: \(error)", file: file, function: function, line: line)
}
} else if error is OWSAssertionError {
owsFailDebug("Unexpected error: \(error)")
} else {
owsFailDebugUnlessNetworkFailure(error)
}
}
// MARK: - URLs
extension MobileCoinAPI {
static func formatAsBase58(publicAddress: MobileCoin.PublicAddress) -> String {
return Base58Coder.encode(publicAddress)
}
static func parseAsPublicAddress(url: URL) -> MobileCoin.PublicAddress? {
let result = MobUri.decode(uri: url.absoluteString)
switch result {
case .success(let payload):
switch payload {
case .publicAddress(let publicAddress):
return publicAddress
case .paymentRequest(let paymentRequest):
// TODO: We could honor the amount and memo.
return paymentRequest.publicAddress
case .transferPayload:
// TODO: We could handle transferPayload.
owsFailDebug("Unexpected payload.")
return nil
}
case .failure(let error):
let error = Self.convertMCError(error: error)
owsFailDebugUnlessMCNetworkFailure(error)
return nil
}
}
static func parse(publicAddressBase58 base58: String) -> MobileCoin.PublicAddress? {
guard let result = Base58Coder.decode(base58) else {
Logger.verbose("Invalid base58: \(base58)")
Logger.warn("Invalid base58.")
return nil
}
switch result {
case .publicAddress(let publicAddress):
return publicAddress
default:
Logger.verbose("Invalid base58: \(base58)")
Logger.warn("Invalid base58.")
return nil
}
}
}