mirror of
https://github.com/aljazceru/breez-sdk-liquid.git
synced 2025-12-19 15:04:24 +01:00
2b64708e36
* feat: switch to pending state when receive lockup is in the mempool * rebasing * fix: move socket update logic to sub-crate * Update payments query, to avoid duplicate Receive Swaps This can happen if the app is stopped before the temporary lockup tx is removed from the DB. The Receive Swap would then forever result in two payments in list_payments. * Add comments to clarify use of temp lockup txid * Re-generate flutter bridge bindings * feat: set Payment `tx_id` as optional and change `list_payments` logic * fix: debug typo * fix: undo `remove_temporary_tx` changes * fix: switch to full join rather than manual filtering * fix: bindings * fix: improve error handling when tx data is not present * fix: RN bindings * fix: exclude Created receives from the list * fix: fixing nits * Re-generate FRB bindings --------- Co-authored-by: ok300 <106775972+ok300@users.noreply.github.com>
1064 lines
42 KiB
Swift
1064 lines
42 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"))
|
|
}
|
|
|
|
return Config(
|
|
boltzUrl: boltzUrl,
|
|
electrumUrl: electrumUrl,
|
|
workingDir: workingDir,
|
|
network: network,
|
|
paymentTimeoutSec: paymentTimeoutSec
|
|
)
|
|
}
|
|
|
|
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,
|
|
]
|
|
}
|
|
|
|
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)"
|
|
}
|
|
}
|