mirror of
https://github.com/aljazceru/breez-sdk-liquid.git
synced 2025-12-19 06:54:25 +01:00
1078 lines
43 KiB
Swift
1078 lines
43 KiB
Swift
import BreezLiquidSDK
|
|
import Foundation
|
|
|
|
enum BreezLiquidSDKMapper {
|
|
static func asBackupRequest(backupRequest: [String: Any?]) throws -> BackupRequest {
|
|
var backupPath: String?
|
|
if hasNonNilKey(data: backupRequest, key: "backupPath") {
|
|
guard let backupPathTmp = backupRequest["backupPath"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedValue(fieldName: "backupPath"))
|
|
}
|
|
backupPath = backupPathTmp
|
|
}
|
|
|
|
return BackupRequest(
|
|
backupPath: backupPath)
|
|
}
|
|
|
|
static func dictionaryOf(backupRequest: BackupRequest) -> [String: Any?] {
|
|
return [
|
|
"backupPath": backupRequest.backupPath == nil ? nil : backupRequest.backupPath,
|
|
]
|
|
}
|
|
|
|
static func asBackupRequestList(arr: [Any]) throws -> [BackupRequest] {
|
|
var list = [BackupRequest]()
|
|
for value in arr {
|
|
if let val = value as? [String: Any?] {
|
|
var backupRequest = try asBackupRequest(backupRequest: val)
|
|
list.append(backupRequest)
|
|
} else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "BackupRequest"))
|
|
}
|
|
}
|
|
return list
|
|
}
|
|
|
|
static func arrayOf(backupRequestList: [BackupRequest]) -> [Any] {
|
|
return backupRequestList.map { v -> [String: Any?] in dictionaryOf(backupRequest: v) }
|
|
}
|
|
|
|
static func asConfig(config: [String: Any?]) throws -> Config {
|
|
guard let boltzUrl = config["boltzUrl"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "boltzUrl", typeName: "Config"))
|
|
}
|
|
guard let electrumUrl = config["electrumUrl"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "electrumUrl", typeName: "Config"))
|
|
}
|
|
guard let workingDir = config["workingDir"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "workingDir", typeName: "Config"))
|
|
}
|
|
guard let networkTmp = config["network"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "network", typeName: "Config"))
|
|
}
|
|
let network = try asNetwork(network: networkTmp)
|
|
|
|
guard let paymentTimeoutSec = config["paymentTimeoutSec"] as? UInt64 else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "paymentTimeoutSec", typeName: "Config"))
|
|
}
|
|
guard let zeroConfMinFeeRate = config["zeroConfMinFeeRate"] as? Float else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "zeroConfMinFeeRate", typeName: "Config"))
|
|
}
|
|
var zeroConfMaxAmountSat: UInt64?
|
|
if hasNonNilKey(data: config, key: "zeroConfMaxAmountSat") {
|
|
guard let zeroConfMaxAmountSatTmp = config["zeroConfMaxAmountSat"] as? UInt64 else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedValue(fieldName: "zeroConfMaxAmountSat"))
|
|
}
|
|
zeroConfMaxAmountSat = zeroConfMaxAmountSatTmp
|
|
}
|
|
|
|
return Config(
|
|
boltzUrl: boltzUrl,
|
|
electrumUrl: electrumUrl,
|
|
workingDir: workingDir,
|
|
network: network,
|
|
paymentTimeoutSec: paymentTimeoutSec,
|
|
zeroConfMinFeeRate: zeroConfMinFeeRate,
|
|
zeroConfMaxAmountSat: zeroConfMaxAmountSat
|
|
)
|
|
}
|
|
|
|
static func dictionaryOf(config: Config) -> [String: Any?] {
|
|
return [
|
|
"boltzUrl": config.boltzUrl,
|
|
"electrumUrl": config.electrumUrl,
|
|
"workingDir": config.workingDir,
|
|
"network": valueOf(network: config.network),
|
|
"paymentTimeoutSec": config.paymentTimeoutSec,
|
|
"zeroConfMinFeeRate": config.zeroConfMinFeeRate,
|
|
"zeroConfMaxAmountSat": config.zeroConfMaxAmountSat == nil ? nil : config.zeroConfMaxAmountSat,
|
|
]
|
|
}
|
|
|
|
static func asConfigList(arr: [Any]) throws -> [Config] {
|
|
var list = [Config]()
|
|
for value in arr {
|
|
if let val = value as? [String: Any?] {
|
|
var config = try asConfig(config: val)
|
|
list.append(config)
|
|
} else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "Config"))
|
|
}
|
|
}
|
|
return list
|
|
}
|
|
|
|
static func arrayOf(configList: [Config]) -> [Any] {
|
|
return configList.map { v -> [String: Any?] in dictionaryOf(config: v) }
|
|
}
|
|
|
|
static func asConnectRequest(connectRequest: [String: Any?]) throws -> ConnectRequest {
|
|
guard let configTmp = connectRequest["config"] as? [String: Any?] else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "config", typeName: "ConnectRequest"))
|
|
}
|
|
let config = try asConfig(config: configTmp)
|
|
|
|
guard let mnemonic = connectRequest["mnemonic"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "mnemonic", typeName: "ConnectRequest"))
|
|
}
|
|
|
|
return ConnectRequest(
|
|
config: config,
|
|
mnemonic: mnemonic
|
|
)
|
|
}
|
|
|
|
static func dictionaryOf(connectRequest: ConnectRequest) -> [String: Any?] {
|
|
return [
|
|
"config": dictionaryOf(config: connectRequest.config),
|
|
"mnemonic": connectRequest.mnemonic,
|
|
]
|
|
}
|
|
|
|
static func asConnectRequestList(arr: [Any]) throws -> [ConnectRequest] {
|
|
var list = [ConnectRequest]()
|
|
for value in arr {
|
|
if let val = value as? [String: Any?] {
|
|
var connectRequest = try asConnectRequest(connectRequest: val)
|
|
list.append(connectRequest)
|
|
} else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "ConnectRequest"))
|
|
}
|
|
}
|
|
return list
|
|
}
|
|
|
|
static func arrayOf(connectRequestList: [ConnectRequest]) -> [Any] {
|
|
return connectRequestList.map { v -> [String: Any?] in dictionaryOf(connectRequest: v) }
|
|
}
|
|
|
|
static func asGetInfoResponse(getInfoResponse: [String: Any?]) throws -> GetInfoResponse {
|
|
guard let balanceSat = getInfoResponse["balanceSat"] as? UInt64 else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "balanceSat", typeName: "GetInfoResponse"))
|
|
}
|
|
guard let pendingSendSat = getInfoResponse["pendingSendSat"] as? UInt64 else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "pendingSendSat", typeName: "GetInfoResponse"))
|
|
}
|
|
guard let pendingReceiveSat = getInfoResponse["pendingReceiveSat"] as? UInt64 else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "pendingReceiveSat", typeName: "GetInfoResponse"))
|
|
}
|
|
guard let pubkey = getInfoResponse["pubkey"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "pubkey", typeName: "GetInfoResponse"))
|
|
}
|
|
|
|
return GetInfoResponse(
|
|
balanceSat: balanceSat,
|
|
pendingSendSat: pendingSendSat,
|
|
pendingReceiveSat: pendingReceiveSat,
|
|
pubkey: pubkey
|
|
)
|
|
}
|
|
|
|
static func dictionaryOf(getInfoResponse: GetInfoResponse) -> [String: Any?] {
|
|
return [
|
|
"balanceSat": getInfoResponse.balanceSat,
|
|
"pendingSendSat": getInfoResponse.pendingSendSat,
|
|
"pendingReceiveSat": getInfoResponse.pendingReceiveSat,
|
|
"pubkey": getInfoResponse.pubkey,
|
|
]
|
|
}
|
|
|
|
static func asGetInfoResponseList(arr: [Any]) throws -> [GetInfoResponse] {
|
|
var list = [GetInfoResponse]()
|
|
for value in arr {
|
|
if let val = value as? [String: Any?] {
|
|
var getInfoResponse = try asGetInfoResponse(getInfoResponse: val)
|
|
list.append(getInfoResponse)
|
|
} else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "GetInfoResponse"))
|
|
}
|
|
}
|
|
return list
|
|
}
|
|
|
|
static func arrayOf(getInfoResponseList: [GetInfoResponse]) -> [Any] {
|
|
return getInfoResponseList.map { v -> [String: Any?] in dictionaryOf(getInfoResponse: v) }
|
|
}
|
|
|
|
static func asLnInvoice(lnInvoice: [String: Any?]) throws -> LnInvoice {
|
|
guard let bolt11 = lnInvoice["bolt11"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "bolt11", typeName: "LnInvoice"))
|
|
}
|
|
guard let networkTmp = lnInvoice["network"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "network", typeName: "LnInvoice"))
|
|
}
|
|
let network = try asNetwork(network: networkTmp)
|
|
|
|
guard let payeePubkey = lnInvoice["payeePubkey"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "payeePubkey", typeName: "LnInvoice"))
|
|
}
|
|
guard let paymentHash = lnInvoice["paymentHash"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "paymentHash", typeName: "LnInvoice"))
|
|
}
|
|
var description: String?
|
|
if hasNonNilKey(data: lnInvoice, key: "description") {
|
|
guard let descriptionTmp = lnInvoice["description"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedValue(fieldName: "description"))
|
|
}
|
|
description = descriptionTmp
|
|
}
|
|
var descriptionHash: String?
|
|
if hasNonNilKey(data: lnInvoice, key: "descriptionHash") {
|
|
guard let descriptionHashTmp = lnInvoice["descriptionHash"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedValue(fieldName: "descriptionHash"))
|
|
}
|
|
descriptionHash = descriptionHashTmp
|
|
}
|
|
var amountMsat: UInt64?
|
|
if hasNonNilKey(data: lnInvoice, key: "amountMsat") {
|
|
guard let amountMsatTmp = lnInvoice["amountMsat"] as? UInt64 else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedValue(fieldName: "amountMsat"))
|
|
}
|
|
amountMsat = amountMsatTmp
|
|
}
|
|
guard let timestamp = lnInvoice["timestamp"] as? UInt64 else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "timestamp", typeName: "LnInvoice"))
|
|
}
|
|
guard let expiry = lnInvoice["expiry"] as? UInt64 else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "expiry", typeName: "LnInvoice"))
|
|
}
|
|
guard let routingHintsTmp = lnInvoice["routingHints"] as? [[String: Any?]] else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "routingHints", typeName: "LnInvoice"))
|
|
}
|
|
let routingHints = try asRouteHintList(arr: routingHintsTmp)
|
|
|
|
guard let paymentSecret = lnInvoice["paymentSecret"] as? [UInt8] else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "paymentSecret", typeName: "LnInvoice"))
|
|
}
|
|
guard let minFinalCltvExpiryDelta = lnInvoice["minFinalCltvExpiryDelta"] as? UInt64 else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "minFinalCltvExpiryDelta", typeName: "LnInvoice"))
|
|
}
|
|
|
|
return LnInvoice(
|
|
bolt11: bolt11,
|
|
network: network,
|
|
payeePubkey: payeePubkey,
|
|
paymentHash: paymentHash,
|
|
description: description,
|
|
descriptionHash: descriptionHash,
|
|
amountMsat: amountMsat,
|
|
timestamp: timestamp,
|
|
expiry: expiry,
|
|
routingHints: routingHints,
|
|
paymentSecret: paymentSecret,
|
|
minFinalCltvExpiryDelta: minFinalCltvExpiryDelta
|
|
)
|
|
}
|
|
|
|
static func dictionaryOf(lnInvoice: LnInvoice) -> [String: Any?] {
|
|
return [
|
|
"bolt11": lnInvoice.bolt11,
|
|
"network": valueOf(network: lnInvoice.network),
|
|
"payeePubkey": lnInvoice.payeePubkey,
|
|
"paymentHash": lnInvoice.paymentHash,
|
|
"description": lnInvoice.description == nil ? nil : lnInvoice.description,
|
|
"descriptionHash": lnInvoice.descriptionHash == nil ? nil : lnInvoice.descriptionHash,
|
|
"amountMsat": lnInvoice.amountMsat == nil ? nil : lnInvoice.amountMsat,
|
|
"timestamp": lnInvoice.timestamp,
|
|
"expiry": lnInvoice.expiry,
|
|
"routingHints": arrayOf(routeHintList: lnInvoice.routingHints),
|
|
"paymentSecret": lnInvoice.paymentSecret,
|
|
"minFinalCltvExpiryDelta": lnInvoice.minFinalCltvExpiryDelta,
|
|
]
|
|
}
|
|
|
|
static func asLnInvoiceList(arr: [Any]) throws -> [LnInvoice] {
|
|
var list = [LnInvoice]()
|
|
for value in arr {
|
|
if let val = value as? [String: Any?] {
|
|
var lnInvoice = try asLnInvoice(lnInvoice: val)
|
|
list.append(lnInvoice)
|
|
} else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "LnInvoice"))
|
|
}
|
|
}
|
|
return list
|
|
}
|
|
|
|
static func arrayOf(lnInvoiceList: [LnInvoice]) -> [Any] {
|
|
return lnInvoiceList.map { v -> [String: Any?] in dictionaryOf(lnInvoice: v) }
|
|
}
|
|
|
|
static func asLogEntry(logEntry: [String: Any?]) throws -> LogEntry {
|
|
guard let line = logEntry["line"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "line", typeName: "LogEntry"))
|
|
}
|
|
guard let level = logEntry["level"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "level", typeName: "LogEntry"))
|
|
}
|
|
|
|
return LogEntry(
|
|
line: line,
|
|
level: level
|
|
)
|
|
}
|
|
|
|
static func dictionaryOf(logEntry: LogEntry) -> [String: Any?] {
|
|
return [
|
|
"line": logEntry.line,
|
|
"level": logEntry.level,
|
|
]
|
|
}
|
|
|
|
static func asLogEntryList(arr: [Any]) throws -> [LogEntry] {
|
|
var list = [LogEntry]()
|
|
for value in arr {
|
|
if let val = value as? [String: Any?] {
|
|
var logEntry = try asLogEntry(logEntry: val)
|
|
list.append(logEntry)
|
|
} else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "LogEntry"))
|
|
}
|
|
}
|
|
return list
|
|
}
|
|
|
|
static func arrayOf(logEntryList: [LogEntry]) -> [Any] {
|
|
return logEntryList.map { v -> [String: Any?] in dictionaryOf(logEntry: v) }
|
|
}
|
|
|
|
static func asPayment(payment: [String: Any?]) throws -> Payment {
|
|
var txId: String?
|
|
if hasNonNilKey(data: payment, key: "txId") {
|
|
guard let txIdTmp = payment["txId"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedValue(fieldName: "txId"))
|
|
}
|
|
txId = txIdTmp
|
|
}
|
|
var swapId: String?
|
|
if hasNonNilKey(data: payment, key: "swapId") {
|
|
guard let swapIdTmp = payment["swapId"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedValue(fieldName: "swapId"))
|
|
}
|
|
swapId = swapIdTmp
|
|
}
|
|
guard let timestamp = payment["timestamp"] as? UInt32 else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "timestamp", typeName: "Payment"))
|
|
}
|
|
guard let amountSat = payment["amountSat"] as? UInt64 else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "amountSat", typeName: "Payment"))
|
|
}
|
|
guard let feesSat = payment["feesSat"] as? UInt64 else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "feesSat", typeName: "Payment"))
|
|
}
|
|
var preimage: String?
|
|
if hasNonNilKey(data: payment, key: "preimage") {
|
|
guard let preimageTmp = payment["preimage"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedValue(fieldName: "preimage"))
|
|
}
|
|
preimage = preimageTmp
|
|
}
|
|
var refundTxId: String?
|
|
if hasNonNilKey(data: payment, key: "refundTxId") {
|
|
guard let refundTxIdTmp = payment["refundTxId"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedValue(fieldName: "refundTxId"))
|
|
}
|
|
refundTxId = refundTxIdTmp
|
|
}
|
|
var refundTxAmountSat: UInt64?
|
|
if hasNonNilKey(data: payment, key: "refundTxAmountSat") {
|
|
guard let refundTxAmountSatTmp = payment["refundTxAmountSat"] as? UInt64 else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedValue(fieldName: "refundTxAmountSat"))
|
|
}
|
|
refundTxAmountSat = refundTxAmountSatTmp
|
|
}
|
|
guard let paymentTypeTmp = payment["paymentType"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "paymentType", typeName: "Payment"))
|
|
}
|
|
let paymentType = try asPaymentType(paymentType: paymentTypeTmp)
|
|
|
|
guard let statusTmp = payment["status"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "status", typeName: "Payment"))
|
|
}
|
|
let status = try asPaymentState(paymentState: statusTmp)
|
|
|
|
return Payment(
|
|
txId: txId,
|
|
swapId: swapId,
|
|
timestamp: timestamp,
|
|
amountSat: amountSat,
|
|
feesSat: feesSat,
|
|
preimage: preimage,
|
|
refundTxId: refundTxId,
|
|
refundTxAmountSat: refundTxAmountSat,
|
|
paymentType: paymentType,
|
|
status: status
|
|
)
|
|
}
|
|
|
|
static func dictionaryOf(payment: Payment) -> [String: Any?] {
|
|
return [
|
|
"txId": payment.txId == nil ? nil : payment.txId,
|
|
"swapId": payment.swapId == nil ? nil : payment.swapId,
|
|
"timestamp": payment.timestamp,
|
|
"amountSat": payment.amountSat,
|
|
"feesSat": payment.feesSat,
|
|
"preimage": payment.preimage == nil ? nil : payment.preimage,
|
|
"refundTxId": payment.refundTxId == nil ? nil : payment.refundTxId,
|
|
"refundTxAmountSat": payment.refundTxAmountSat == nil ? nil : payment.refundTxAmountSat,
|
|
"paymentType": valueOf(paymentType: payment.paymentType),
|
|
"status": valueOf(paymentState: payment.status),
|
|
]
|
|
}
|
|
|
|
static func asPaymentList(arr: [Any]) throws -> [Payment] {
|
|
var list = [Payment]()
|
|
for value in arr {
|
|
if let val = value as? [String: Any?] {
|
|
var payment = try asPayment(payment: val)
|
|
list.append(payment)
|
|
} else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "Payment"))
|
|
}
|
|
}
|
|
return list
|
|
}
|
|
|
|
static func arrayOf(paymentList: [Payment]) -> [Any] {
|
|
return paymentList.map { v -> [String: Any?] in dictionaryOf(payment: v) }
|
|
}
|
|
|
|
static func asPrepareReceiveRequest(prepareReceiveRequest: [String: Any?]) throws -> PrepareReceiveRequest {
|
|
guard let payerAmountSat = prepareReceiveRequest["payerAmountSat"] as? UInt64 else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "payerAmountSat", typeName: "PrepareReceiveRequest"))
|
|
}
|
|
|
|
return PrepareReceiveRequest(
|
|
payerAmountSat: payerAmountSat)
|
|
}
|
|
|
|
static func dictionaryOf(prepareReceiveRequest: PrepareReceiveRequest) -> [String: Any?] {
|
|
return [
|
|
"payerAmountSat": prepareReceiveRequest.payerAmountSat,
|
|
]
|
|
}
|
|
|
|
static func asPrepareReceiveRequestList(arr: [Any]) throws -> [PrepareReceiveRequest] {
|
|
var list = [PrepareReceiveRequest]()
|
|
for value in arr {
|
|
if let val = value as? [String: Any?] {
|
|
var prepareReceiveRequest = try asPrepareReceiveRequest(prepareReceiveRequest: val)
|
|
list.append(prepareReceiveRequest)
|
|
} else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "PrepareReceiveRequest"))
|
|
}
|
|
}
|
|
return list
|
|
}
|
|
|
|
static func arrayOf(prepareReceiveRequestList: [PrepareReceiveRequest]) -> [Any] {
|
|
return prepareReceiveRequestList.map { v -> [String: Any?] in dictionaryOf(prepareReceiveRequest: v) }
|
|
}
|
|
|
|
static func asPrepareReceiveResponse(prepareReceiveResponse: [String: Any?]) throws -> PrepareReceiveResponse {
|
|
guard let payerAmountSat = prepareReceiveResponse["payerAmountSat"] as? UInt64 else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "payerAmountSat", typeName: "PrepareReceiveResponse"))
|
|
}
|
|
guard let feesSat = prepareReceiveResponse["feesSat"] as? UInt64 else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "feesSat", typeName: "PrepareReceiveResponse"))
|
|
}
|
|
|
|
return PrepareReceiveResponse(
|
|
payerAmountSat: payerAmountSat,
|
|
feesSat: feesSat
|
|
)
|
|
}
|
|
|
|
static func dictionaryOf(prepareReceiveResponse: PrepareReceiveResponse) -> [String: Any?] {
|
|
return [
|
|
"payerAmountSat": prepareReceiveResponse.payerAmountSat,
|
|
"feesSat": prepareReceiveResponse.feesSat,
|
|
]
|
|
}
|
|
|
|
static func asPrepareReceiveResponseList(arr: [Any]) throws -> [PrepareReceiveResponse] {
|
|
var list = [PrepareReceiveResponse]()
|
|
for value in arr {
|
|
if let val = value as? [String: Any?] {
|
|
var prepareReceiveResponse = try asPrepareReceiveResponse(prepareReceiveResponse: val)
|
|
list.append(prepareReceiveResponse)
|
|
} else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "PrepareReceiveResponse"))
|
|
}
|
|
}
|
|
return list
|
|
}
|
|
|
|
static func arrayOf(prepareReceiveResponseList: [PrepareReceiveResponse]) -> [Any] {
|
|
return prepareReceiveResponseList.map { v -> [String: Any?] in dictionaryOf(prepareReceiveResponse: v) }
|
|
}
|
|
|
|
static func asPrepareSendRequest(prepareSendRequest: [String: Any?]) throws -> PrepareSendRequest {
|
|
guard let invoice = prepareSendRequest["invoice"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "invoice", typeName: "PrepareSendRequest"))
|
|
}
|
|
|
|
return PrepareSendRequest(
|
|
invoice: invoice)
|
|
}
|
|
|
|
static func dictionaryOf(prepareSendRequest: PrepareSendRequest) -> [String: Any?] {
|
|
return [
|
|
"invoice": prepareSendRequest.invoice,
|
|
]
|
|
}
|
|
|
|
static func asPrepareSendRequestList(arr: [Any]) throws -> [PrepareSendRequest] {
|
|
var list = [PrepareSendRequest]()
|
|
for value in arr {
|
|
if let val = value as? [String: Any?] {
|
|
var prepareSendRequest = try asPrepareSendRequest(prepareSendRequest: val)
|
|
list.append(prepareSendRequest)
|
|
} else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "PrepareSendRequest"))
|
|
}
|
|
}
|
|
return list
|
|
}
|
|
|
|
static func arrayOf(prepareSendRequestList: [PrepareSendRequest]) -> [Any] {
|
|
return prepareSendRequestList.map { v -> [String: Any?] in dictionaryOf(prepareSendRequest: v) }
|
|
}
|
|
|
|
static func asPrepareSendResponse(prepareSendResponse: [String: Any?]) throws -> PrepareSendResponse {
|
|
guard let invoice = prepareSendResponse["invoice"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "invoice", typeName: "PrepareSendResponse"))
|
|
}
|
|
guard let feesSat = prepareSendResponse["feesSat"] as? UInt64 else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "feesSat", typeName: "PrepareSendResponse"))
|
|
}
|
|
|
|
return PrepareSendResponse(
|
|
invoice: invoice,
|
|
feesSat: feesSat
|
|
)
|
|
}
|
|
|
|
static func dictionaryOf(prepareSendResponse: PrepareSendResponse) -> [String: Any?] {
|
|
return [
|
|
"invoice": prepareSendResponse.invoice,
|
|
"feesSat": prepareSendResponse.feesSat,
|
|
]
|
|
}
|
|
|
|
static func asPrepareSendResponseList(arr: [Any]) throws -> [PrepareSendResponse] {
|
|
var list = [PrepareSendResponse]()
|
|
for value in arr {
|
|
if let val = value as? [String: Any?] {
|
|
var prepareSendResponse = try asPrepareSendResponse(prepareSendResponse: val)
|
|
list.append(prepareSendResponse)
|
|
} else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "PrepareSendResponse"))
|
|
}
|
|
}
|
|
return list
|
|
}
|
|
|
|
static func arrayOf(prepareSendResponseList: [PrepareSendResponse]) -> [Any] {
|
|
return prepareSendResponseList.map { v -> [String: Any?] in dictionaryOf(prepareSendResponse: v) }
|
|
}
|
|
|
|
static func asReceivePaymentResponse(receivePaymentResponse: [String: Any?]) throws -> ReceivePaymentResponse {
|
|
guard let id = receivePaymentResponse["id"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "id", typeName: "ReceivePaymentResponse"))
|
|
}
|
|
guard let invoice = receivePaymentResponse["invoice"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "invoice", typeName: "ReceivePaymentResponse"))
|
|
}
|
|
|
|
return ReceivePaymentResponse(
|
|
id: id,
|
|
invoice: invoice
|
|
)
|
|
}
|
|
|
|
static func dictionaryOf(receivePaymentResponse: ReceivePaymentResponse) -> [String: Any?] {
|
|
return [
|
|
"id": receivePaymentResponse.id,
|
|
"invoice": receivePaymentResponse.invoice,
|
|
]
|
|
}
|
|
|
|
static func asReceivePaymentResponseList(arr: [Any]) throws -> [ReceivePaymentResponse] {
|
|
var list = [ReceivePaymentResponse]()
|
|
for value in arr {
|
|
if let val = value as? [String: Any?] {
|
|
var receivePaymentResponse = try asReceivePaymentResponse(receivePaymentResponse: val)
|
|
list.append(receivePaymentResponse)
|
|
} else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "ReceivePaymentResponse"))
|
|
}
|
|
}
|
|
return list
|
|
}
|
|
|
|
static func arrayOf(receivePaymentResponseList: [ReceivePaymentResponse]) -> [Any] {
|
|
return receivePaymentResponseList.map { v -> [String: Any?] in dictionaryOf(receivePaymentResponse: v) }
|
|
}
|
|
|
|
static func asRestoreRequest(restoreRequest: [String: Any?]) throws -> RestoreRequest {
|
|
var backupPath: String?
|
|
if hasNonNilKey(data: restoreRequest, key: "backupPath") {
|
|
guard let backupPathTmp = restoreRequest["backupPath"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedValue(fieldName: "backupPath"))
|
|
}
|
|
backupPath = backupPathTmp
|
|
}
|
|
|
|
return RestoreRequest(
|
|
backupPath: backupPath)
|
|
}
|
|
|
|
static func dictionaryOf(restoreRequest: RestoreRequest) -> [String: Any?] {
|
|
return [
|
|
"backupPath": restoreRequest.backupPath == nil ? nil : restoreRequest.backupPath,
|
|
]
|
|
}
|
|
|
|
static func asRestoreRequestList(arr: [Any]) throws -> [RestoreRequest] {
|
|
var list = [RestoreRequest]()
|
|
for value in arr {
|
|
if let val = value as? [String: Any?] {
|
|
var restoreRequest = try asRestoreRequest(restoreRequest: val)
|
|
list.append(restoreRequest)
|
|
} else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "RestoreRequest"))
|
|
}
|
|
}
|
|
return list
|
|
}
|
|
|
|
static func arrayOf(restoreRequestList: [RestoreRequest]) -> [Any] {
|
|
return restoreRequestList.map { v -> [String: Any?] in dictionaryOf(restoreRequest: v) }
|
|
}
|
|
|
|
static func asRouteHint(routeHint: [String: Any?]) throws -> RouteHint {
|
|
guard let hopsTmp = routeHint["hops"] as? [[String: Any?]] else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "hops", typeName: "RouteHint"))
|
|
}
|
|
let hops = try asRouteHintHopList(arr: hopsTmp)
|
|
|
|
return RouteHint(
|
|
hops: hops)
|
|
}
|
|
|
|
static func dictionaryOf(routeHint: RouteHint) -> [String: Any?] {
|
|
return [
|
|
"hops": arrayOf(routeHintHopList: routeHint.hops),
|
|
]
|
|
}
|
|
|
|
static func asRouteHintList(arr: [Any]) throws -> [RouteHint] {
|
|
var list = [RouteHint]()
|
|
for value in arr {
|
|
if let val = value as? [String: Any?] {
|
|
var routeHint = try asRouteHint(routeHint: val)
|
|
list.append(routeHint)
|
|
} else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "RouteHint"))
|
|
}
|
|
}
|
|
return list
|
|
}
|
|
|
|
static func arrayOf(routeHintList: [RouteHint]) -> [Any] {
|
|
return routeHintList.map { v -> [String: Any?] in dictionaryOf(routeHint: v) }
|
|
}
|
|
|
|
static func asRouteHintHop(routeHintHop: [String: Any?]) throws -> RouteHintHop {
|
|
guard let srcNodeId = routeHintHop["srcNodeId"] as? String else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "srcNodeId", typeName: "RouteHintHop"))
|
|
}
|
|
guard let shortChannelId = routeHintHop["shortChannelId"] as? UInt64 else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "shortChannelId", typeName: "RouteHintHop"))
|
|
}
|
|
guard let feesBaseMsat = routeHintHop["feesBaseMsat"] as? UInt32 else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "feesBaseMsat", typeName: "RouteHintHop"))
|
|
}
|
|
guard let feesProportionalMillionths = routeHintHop["feesProportionalMillionths"] as? UInt32 else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "feesProportionalMillionths", typeName: "RouteHintHop"))
|
|
}
|
|
guard let cltvExpiryDelta = routeHintHop["cltvExpiryDelta"] as? UInt64 else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "cltvExpiryDelta", typeName: "RouteHintHop"))
|
|
}
|
|
var htlcMinimumMsat: UInt64?
|
|
if hasNonNilKey(data: routeHintHop, key: "htlcMinimumMsat") {
|
|
guard let htlcMinimumMsatTmp = routeHintHop["htlcMinimumMsat"] as? UInt64 else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedValue(fieldName: "htlcMinimumMsat"))
|
|
}
|
|
htlcMinimumMsat = htlcMinimumMsatTmp
|
|
}
|
|
var htlcMaximumMsat: UInt64?
|
|
if hasNonNilKey(data: routeHintHop, key: "htlcMaximumMsat") {
|
|
guard let htlcMaximumMsatTmp = routeHintHop["htlcMaximumMsat"] as? UInt64 else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedValue(fieldName: "htlcMaximumMsat"))
|
|
}
|
|
htlcMaximumMsat = htlcMaximumMsatTmp
|
|
}
|
|
|
|
return RouteHintHop(
|
|
srcNodeId: srcNodeId,
|
|
shortChannelId: shortChannelId,
|
|
feesBaseMsat: feesBaseMsat,
|
|
feesProportionalMillionths: feesProportionalMillionths,
|
|
cltvExpiryDelta: cltvExpiryDelta,
|
|
htlcMinimumMsat: htlcMinimumMsat,
|
|
htlcMaximumMsat: htlcMaximumMsat
|
|
)
|
|
}
|
|
|
|
static func dictionaryOf(routeHintHop: RouteHintHop) -> [String: Any?] {
|
|
return [
|
|
"srcNodeId": routeHintHop.srcNodeId,
|
|
"shortChannelId": routeHintHop.shortChannelId,
|
|
"feesBaseMsat": routeHintHop.feesBaseMsat,
|
|
"feesProportionalMillionths": routeHintHop.feesProportionalMillionths,
|
|
"cltvExpiryDelta": routeHintHop.cltvExpiryDelta,
|
|
"htlcMinimumMsat": routeHintHop.htlcMinimumMsat == nil ? nil : routeHintHop.htlcMinimumMsat,
|
|
"htlcMaximumMsat": routeHintHop.htlcMaximumMsat == nil ? nil : routeHintHop.htlcMaximumMsat,
|
|
]
|
|
}
|
|
|
|
static func asRouteHintHopList(arr: [Any]) throws -> [RouteHintHop] {
|
|
var list = [RouteHintHop]()
|
|
for value in arr {
|
|
if let val = value as? [String: Any?] {
|
|
var routeHintHop = try asRouteHintHop(routeHintHop: val)
|
|
list.append(routeHintHop)
|
|
} else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "RouteHintHop"))
|
|
}
|
|
}
|
|
return list
|
|
}
|
|
|
|
static func arrayOf(routeHintHopList: [RouteHintHop]) -> [Any] {
|
|
return routeHintHopList.map { v -> [String: Any?] in dictionaryOf(routeHintHop: v) }
|
|
}
|
|
|
|
static func asSendPaymentResponse(sendPaymentResponse: [String: Any?]) throws -> SendPaymentResponse {
|
|
guard let paymentTmp = sendPaymentResponse["payment"] as? [String: Any?] else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "payment", typeName: "SendPaymentResponse"))
|
|
}
|
|
let payment = try asPayment(payment: paymentTmp)
|
|
|
|
return SendPaymentResponse(
|
|
payment: payment)
|
|
}
|
|
|
|
static func dictionaryOf(sendPaymentResponse: SendPaymentResponse) -> [String: Any?] {
|
|
return [
|
|
"payment": dictionaryOf(payment: sendPaymentResponse.payment),
|
|
]
|
|
}
|
|
|
|
static func asSendPaymentResponseList(arr: [Any]) throws -> [SendPaymentResponse] {
|
|
var list = [SendPaymentResponse]()
|
|
for value in arr {
|
|
if let val = value as? [String: Any?] {
|
|
var sendPaymentResponse = try asSendPaymentResponse(sendPaymentResponse: val)
|
|
list.append(sendPaymentResponse)
|
|
} else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "SendPaymentResponse"))
|
|
}
|
|
}
|
|
return list
|
|
}
|
|
|
|
static func arrayOf(sendPaymentResponseList: [SendPaymentResponse]) -> [Any] {
|
|
return sendPaymentResponseList.map { v -> [String: Any?] in dictionaryOf(sendPaymentResponse: v) }
|
|
}
|
|
|
|
static func asLiquidSdkEvent(liquidSdkEvent: [String: Any?]) throws -> LiquidSdkEvent {
|
|
let type = liquidSdkEvent["type"] as! String
|
|
if type == "paymentFailed" {
|
|
guard let detailsTmp = liquidSdkEvent["details"] as? [String: Any?] else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "details", typeName: "LiquidSdkEvent"))
|
|
}
|
|
let _details = try asPayment(payment: detailsTmp)
|
|
|
|
return LiquidSdkEvent.paymentFailed(details: _details)
|
|
}
|
|
if type == "paymentPending" {
|
|
guard let detailsTmp = liquidSdkEvent["details"] as? [String: Any?] else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "details", typeName: "LiquidSdkEvent"))
|
|
}
|
|
let _details = try asPayment(payment: detailsTmp)
|
|
|
|
return LiquidSdkEvent.paymentPending(details: _details)
|
|
}
|
|
if type == "paymentRefunded" {
|
|
guard let detailsTmp = liquidSdkEvent["details"] as? [String: Any?] else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "details", typeName: "LiquidSdkEvent"))
|
|
}
|
|
let _details = try asPayment(payment: detailsTmp)
|
|
|
|
return LiquidSdkEvent.paymentRefunded(details: _details)
|
|
}
|
|
if type == "paymentRefundPending" {
|
|
guard let detailsTmp = liquidSdkEvent["details"] as? [String: Any?] else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "details", typeName: "LiquidSdkEvent"))
|
|
}
|
|
let _details = try asPayment(payment: detailsTmp)
|
|
|
|
return LiquidSdkEvent.paymentRefundPending(details: _details)
|
|
}
|
|
if type == "paymentSucceeded" {
|
|
guard let detailsTmp = liquidSdkEvent["details"] as? [String: Any?] else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "details", typeName: "LiquidSdkEvent"))
|
|
}
|
|
let _details = try asPayment(payment: detailsTmp)
|
|
|
|
return LiquidSdkEvent.paymentSucceeded(details: _details)
|
|
}
|
|
if type == "paymentWaitingConfirmation" {
|
|
guard let detailsTmp = liquidSdkEvent["details"] as? [String: Any?] else {
|
|
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "details", typeName: "LiquidSdkEvent"))
|
|
}
|
|
let _details = try asPayment(payment: detailsTmp)
|
|
|
|
return LiquidSdkEvent.paymentWaitingConfirmation(details: _details)
|
|
}
|
|
if type == "synced" {
|
|
return LiquidSdkEvent.synced
|
|
}
|
|
|
|
throw LiquidSdkError.Generic(message: "Unexpected type \(type) for enum LiquidSdkEvent")
|
|
}
|
|
|
|
static func dictionaryOf(liquidSdkEvent: LiquidSdkEvent) -> [String: Any?] {
|
|
switch liquidSdkEvent {
|
|
case let .paymentFailed(
|
|
details
|
|
):
|
|
return [
|
|
"type": "paymentFailed",
|
|
"details": dictionaryOf(payment: details),
|
|
]
|
|
|
|
case let .paymentPending(
|
|
details
|
|
):
|
|
return [
|
|
"type": "paymentPending",
|
|
"details": dictionaryOf(payment: details),
|
|
]
|
|
|
|
case let .paymentRefunded(
|
|
details
|
|
):
|
|
return [
|
|
"type": "paymentRefunded",
|
|
"details": dictionaryOf(payment: details),
|
|
]
|
|
|
|
case let .paymentRefundPending(
|
|
details
|
|
):
|
|
return [
|
|
"type": "paymentRefundPending",
|
|
"details": dictionaryOf(payment: details),
|
|
]
|
|
|
|
case let .paymentSucceeded(
|
|
details
|
|
):
|
|
return [
|
|
"type": "paymentSucceeded",
|
|
"details": dictionaryOf(payment: details),
|
|
]
|
|
|
|
case let .paymentWaitingConfirmation(
|
|
details
|
|
):
|
|
return [
|
|
"type": "paymentWaitingConfirmation",
|
|
"details": dictionaryOf(payment: details),
|
|
]
|
|
|
|
case .synced:
|
|
return [
|
|
"type": "synced",
|
|
]
|
|
}
|
|
}
|
|
|
|
static func arrayOf(liquidSdkEventList: [LiquidSdkEvent]) -> [Any] {
|
|
return liquidSdkEventList.map { v -> [String: Any?] in dictionaryOf(liquidSdkEvent: v) }
|
|
}
|
|
|
|
static func asLiquidSdkEventList(arr: [Any]) throws -> [LiquidSdkEvent] {
|
|
var list = [LiquidSdkEvent]()
|
|
for value in arr {
|
|
if let val = value as? [String: Any?] {
|
|
var liquidSdkEvent = try asLiquidSdkEvent(liquidSdkEvent: val)
|
|
list.append(liquidSdkEvent)
|
|
} else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "LiquidSdkEvent"))
|
|
}
|
|
}
|
|
return list
|
|
}
|
|
|
|
static func asNetwork(network: String) throws -> Network {
|
|
switch network {
|
|
case "mainnet":
|
|
return Network.mainnet
|
|
|
|
case "testnet":
|
|
return Network.testnet
|
|
|
|
default: throw LiquidSdkError.Generic(message: "Invalid variant \(network) for enum Network")
|
|
}
|
|
}
|
|
|
|
static func valueOf(network: Network) -> String {
|
|
switch network {
|
|
case .mainnet:
|
|
return "mainnet"
|
|
|
|
case .testnet:
|
|
return "testnet"
|
|
}
|
|
}
|
|
|
|
static func arrayOf(networkList: [Network]) -> [String] {
|
|
return networkList.map { v -> String in valueOf(network: v) }
|
|
}
|
|
|
|
static func asNetworkList(arr: [Any]) throws -> [Network] {
|
|
var list = [Network]()
|
|
for value in arr {
|
|
if let val = value as? String {
|
|
var network = try asNetwork(network: val)
|
|
list.append(network)
|
|
} else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "Network"))
|
|
}
|
|
}
|
|
return list
|
|
}
|
|
|
|
static func asPaymentState(paymentState: String) throws -> PaymentState {
|
|
switch paymentState {
|
|
case "created":
|
|
return PaymentState.created
|
|
|
|
case "pending":
|
|
return PaymentState.pending
|
|
|
|
case "complete":
|
|
return PaymentState.complete
|
|
|
|
case "failed":
|
|
return PaymentState.failed
|
|
|
|
case "timedOut":
|
|
return PaymentState.timedOut
|
|
|
|
default: throw LiquidSdkError.Generic(message: "Invalid variant \(paymentState) for enum PaymentState")
|
|
}
|
|
}
|
|
|
|
static func valueOf(paymentState: PaymentState) -> String {
|
|
switch paymentState {
|
|
case .created:
|
|
return "created"
|
|
|
|
case .pending:
|
|
return "pending"
|
|
|
|
case .complete:
|
|
return "complete"
|
|
|
|
case .failed:
|
|
return "failed"
|
|
|
|
case .timedOut:
|
|
return "timedOut"
|
|
}
|
|
}
|
|
|
|
static func arrayOf(paymentStateList: [PaymentState]) -> [String] {
|
|
return paymentStateList.map { v -> String in valueOf(paymentState: v) }
|
|
}
|
|
|
|
static func asPaymentStateList(arr: [Any]) throws -> [PaymentState] {
|
|
var list = [PaymentState]()
|
|
for value in arr {
|
|
if let val = value as? String {
|
|
var paymentState = try asPaymentState(paymentState: val)
|
|
list.append(paymentState)
|
|
} else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "PaymentState"))
|
|
}
|
|
}
|
|
return list
|
|
}
|
|
|
|
static func asPaymentType(paymentType: String) throws -> PaymentType {
|
|
switch paymentType {
|
|
case "receive":
|
|
return PaymentType.receive
|
|
|
|
case "send":
|
|
return PaymentType.send
|
|
|
|
default: throw LiquidSdkError.Generic(message: "Invalid variant \(paymentType) for enum PaymentType")
|
|
}
|
|
}
|
|
|
|
static func valueOf(paymentType: PaymentType) -> String {
|
|
switch paymentType {
|
|
case .receive:
|
|
return "receive"
|
|
|
|
case .send:
|
|
return "send"
|
|
}
|
|
}
|
|
|
|
static func arrayOf(paymentTypeList: [PaymentType]) -> [String] {
|
|
return paymentTypeList.map { v -> String in valueOf(paymentType: v) }
|
|
}
|
|
|
|
static func asPaymentTypeList(arr: [Any]) throws -> [PaymentType] {
|
|
var list = [PaymentType]()
|
|
for value in arr {
|
|
if let val = value as? String {
|
|
var paymentType = try asPaymentType(paymentType: val)
|
|
list.append(paymentType)
|
|
} else {
|
|
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "PaymentType"))
|
|
}
|
|
}
|
|
return list
|
|
}
|
|
|
|
static func hasNonNilKey(data: [String: Any?], key: String) -> Bool {
|
|
if let val = data[key] {
|
|
return !(val == nil || val is NSNull)
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
static func errMissingMandatoryField(fieldName: String, typeName: String) -> String {
|
|
return "Missing mandatory field \(fieldName) for type \(typeName)"
|
|
}
|
|
|
|
static func errUnexpectedType(typeName: String) -> String {
|
|
return "Unexpected type \(typeName)"
|
|
}
|
|
|
|
static func errUnexpectedValue(fieldName: String) -> String {
|
|
return "Unexpected value for optional field \(fieldName)"
|
|
}
|
|
}
|