aljaz/breez-sdk-liquid
1
0
Fork 0
mirror of https://github.com/aljazceru/breez-sdk-liquid.git synced 2025-12-19 06:54:25 +01:00
Code Issues Packages Projects Releases Wiki Activity

remove old files

Browse Source
This commit is contained in:
Roei Erez
2024-09-23 15:38:01 +03:00
committed by Ross Savage
parent 8cce2afe5d
commit bbac3f5fc2
5 changed files with 0 additions and 2687 deletions
Download Patch File Download Diff File Expand all files Collapse all files

908
packages/react-native/android/src/main/java/com/breezliquidsdk/BreezLiquidSDKMapper.kt
View File

@@ -1,908 +0,0 @@
package com.breezliquidsdk
import breez_liquid_sdk.*
import com.facebook.react.bridge.*
import java.util.*
fun asBackupRequest(backupRequest: ReadableMap): BackupRequest? {
if (!validateMandatoryFields(
backupRequest,
arrayOf(),
)
) {
return null
}
val backupPath = if (hasNonNullKey(backupRequest, "backupPath")) backupRequest.getString("backupPath") else null
return BackupRequest(
backupPath,
)
}
fun readableMapOf(backupRequest: BackupRequest): ReadableMap =
readableMapOf(
"backupPath" to backupRequest.backupPath,
)
fun asBackupRequestList(arr: ReadableArray): List<BackupRequest> {
val list = ArrayList<BackupRequest>()
for (value in arr.toArrayList()) {
when (value) {
is ReadableMap -> list.add(asBackupRequest(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asConfig(config: ReadableMap): Config? {
if (!validateMandatoryFields(
config,
arrayOf(
"boltzUrl",
"electrumUrl",
"workingDir",
"network",
"paymentTimeoutSec",
),
)
) {
return null
}
val boltzUrl = config.getString("boltzUrl")!!
val electrumUrl = config.getString("electrumUrl")!!
val workingDir = config.getString("workingDir")!!
val network = config.getString("network")?.let { asNetwork(it) }!!
val paymentTimeoutSec = config.getDouble("paymentTimeoutSec").toULong()
return Config(
boltzUrl,
electrumUrl,
workingDir,
network,
paymentTimeoutSec,
)
}
fun readableMapOf(config: Config): ReadableMap =
readableMapOf(
"boltzUrl" to config.boltzUrl,
"electrumUrl" to config.electrumUrl,
"workingDir" to config.workingDir,
"network" to config.network.name.lowercase(),
"paymentTimeoutSec" to config.paymentTimeoutSec,
)
fun asConfigList(arr: ReadableArray): List<Config> {
val list = ArrayList<Config>()
for (value in arr.toArrayList()) {
when (value) {
is ReadableMap -> list.add(asConfig(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asConnectRequest(connectRequest: ReadableMap): ConnectRequest? {
if (!validateMandatoryFields(
connectRequest,
arrayOf(
"config",
"mnemonic",
),
)
) {
return null
}
val config = connectRequest.getMap("config")?.let { asConfig(it) }!!
val mnemonic = connectRequest.getString("mnemonic")!!
return ConnectRequest(
config,
mnemonic,
)
}
fun readableMapOf(connectRequest: ConnectRequest): ReadableMap =
readableMapOf(
"config" to readableMapOf(connectRequest.config),
"mnemonic" to connectRequest.mnemonic,
)
fun asConnectRequestList(arr: ReadableArray): List<ConnectRequest> {
val list = ArrayList<ConnectRequest>()
for (value in arr.toArrayList()) {
when (value) {
is ReadableMap -> list.add(asConnectRequest(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asGetInfoRequest(getInfoRequest: ReadableMap): GetInfoRequest? {
if (!validateMandatoryFields(
getInfoRequest,
arrayOf(
"withScan",
),
)
) {
return null
}
val withScan = getInfoRequest.getBoolean("withScan")
return GetInfoRequest(
withScan,
)
}
fun readableMapOf(getInfoRequest: GetInfoRequest): ReadableMap =
readableMapOf(
"withScan" to getInfoRequest.withScan,
)
fun asGetInfoRequestList(arr: ReadableArray): List<GetInfoRequest> {
val list = ArrayList<GetInfoRequest>()
for (value in arr.toArrayList()) {
when (value) {
is ReadableMap -> list.add(asGetInfoRequest(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asGetInfoResponse(getInfoResponse: ReadableMap): GetInfoResponse? {
if (!validateMandatoryFields(
getInfoResponse,
arrayOf(
"balanceSat",
"pendingSendSat",
"pendingReceiveSat",
"pubkey",
),
)
) {
return null
}
val balanceSat = getInfoResponse.getDouble("balanceSat").toULong()
val pendingSendSat = getInfoResponse.getDouble("pendingSendSat").toULong()
val pendingReceiveSat = getInfoResponse.getDouble("pendingReceiveSat").toULong()
val pubkey = getInfoResponse.getString("pubkey")!!
return GetInfoResponse(
balanceSat,
pendingSendSat,
pendingReceiveSat,
pubkey,
)
}
fun readableMapOf(getInfoResponse: GetInfoResponse): ReadableMap =
readableMapOf(
"balanceSat" to getInfoResponse.balanceSat,
"pendingSendSat" to getInfoResponse.pendingSendSat,
"pendingReceiveSat" to getInfoResponse.pendingReceiveSat,
"pubkey" to getInfoResponse.pubkey,
)
fun asGetInfoResponseList(arr: ReadableArray): List<GetInfoResponse> {
val list = ArrayList<GetInfoResponse>()
for (value in arr.toArrayList()) {
when (value) {
is ReadableMap -> list.add(asGetInfoResponse(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asLnInvoice(lnInvoice: ReadableMap): LnInvoice? {
if (!validateMandatoryFields(
lnInvoice,
arrayOf(
"bolt11",
"network",
"payeePubkey",
"paymentHash",
"timestamp",
"expiry",
"routingHints",
"paymentSecret",
"minFinalCltvExpiryDelta",
),
)
) {
return null
}
val bolt11 = lnInvoice.getString("bolt11")!!
val network = lnInvoice.getString("network")?.let { asNetwork(it) }!!
val payeePubkey = lnInvoice.getString("payeePubkey")!!
val paymentHash = lnInvoice.getString("paymentHash")!!
val description = if (hasNonNullKey(lnInvoice, "description")) lnInvoice.getString("description") else null
val descriptionHash = if (hasNonNullKey(lnInvoice, "descriptionHash")) lnInvoice.getString("descriptionHash") else null
val amountMsat = if (hasNonNullKey(lnInvoice, "amountMsat")) lnInvoice.getDouble("amountMsat").toULong() else null
val timestamp = lnInvoice.getDouble("timestamp").toULong()
val expiry = lnInvoice.getDouble("expiry").toULong()
val routingHints = lnInvoice.getArray("routingHints")?.let { asRouteHintList(it) }!!
val paymentSecret = lnInvoice.getArray("paymentSecret")?.let { asUByteList(it) }!!
val minFinalCltvExpiryDelta = lnInvoice.getDouble("minFinalCltvExpiryDelta").toULong()
return LnInvoice(
bolt11,
network,
payeePubkey,
paymentHash,
description,
descriptionHash,
amountMsat,
timestamp,
expiry,
routingHints,
paymentSecret,
minFinalCltvExpiryDelta,
)
}
fun readableMapOf(lnInvoice: LnInvoice): ReadableMap =
readableMapOf(
"bolt11" to lnInvoice.bolt11,
"network" to lnInvoice.network.name.lowercase(),
"payeePubkey" to lnInvoice.payeePubkey,
"paymentHash" to lnInvoice.paymentHash,
"description" to lnInvoice.description,
"descriptionHash" to lnInvoice.descriptionHash,
"amountMsat" to lnInvoice.amountMsat,
"timestamp" to lnInvoice.timestamp,
"expiry" to lnInvoice.expiry,
"routingHints" to readableArrayOf(lnInvoice.routingHints),
"paymentSecret" to readableArrayOf(lnInvoice.paymentSecret),
"minFinalCltvExpiryDelta" to lnInvoice.minFinalCltvExpiryDelta,
)
fun asLnInvoiceList(arr: ReadableArray): List<LnInvoice> {
val list = ArrayList<LnInvoice>()
for (value in arr.toArrayList()) {
when (value) {
is ReadableMap -> list.add(asLnInvoice(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asLogEntry(logEntry: ReadableMap): LogEntry? {
if (!validateMandatoryFields(
logEntry,
arrayOf(
"line",
"level",
),
)
) {
return null
}
val line = logEntry.getString("line")!!
val level = logEntry.getString("level")!!
return LogEntry(
line,
level,
)
}
fun readableMapOf(logEntry: LogEntry): ReadableMap =
readableMapOf(
"line" to logEntry.line,
"level" to logEntry.level,
)
fun asLogEntryList(arr: ReadableArray): List<LogEntry> {
val list = ArrayList<LogEntry>()
for (value in arr.toArrayList()) {
when (value) {
is ReadableMap -> list.add(asLogEntry(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asPayment(payment: ReadableMap): Payment? {
if (!validateMandatoryFields(
payment,
arrayOf(
"txId",
"timestamp",
"amountSat",
"paymentType",
"status",
),
)
) {
return null
}
val txId = payment.getString("txId")!!
val swapId = if (hasNonNullKey(payment, "swapId")) payment.getString("swapId") else null
val timestamp = payment.getInt("timestamp").toUInt()
val amountSat = payment.getDouble("amountSat").toULong()
val feesSat = if (hasNonNullKey(payment, "feesSat")) payment.getDouble("feesSat").toULong() else null
val preimage = if (hasNonNullKey(payment, "preimage")) payment.getString("preimage") else null
val refundTxId = if (hasNonNullKey(payment, "refundTxId")) payment.getString("refundTxId") else null
val refundTxAmountSat = if (hasNonNullKey(payment, "refundTxAmountSat")) payment.getDouble("refundTxAmountSat").toULong() else null
val paymentType = payment.getString("paymentType")?.let { asPaymentType(it) }!!
val status = payment.getString("status")?.let { asPaymentState(it) }!!
return Payment(
txId,
swapId,
timestamp,
amountSat,
feesSat,
preimage,
refundTxId,
refundTxAmountSat,
paymentType,
status,
)
}
fun readableMapOf(payment: Payment): ReadableMap =
readableMapOf(
"txId" to payment.txId,
"swapId" to payment.swapId,
"timestamp" to payment.timestamp,
"amountSat" to payment.amountSat,
"feesSat" to payment.feesSat,
"preimage" to payment.preimage,
"refundTxId" to payment.refundTxId,
"refundTxAmountSat" to payment.refundTxAmountSat,
"paymentType" to payment.paymentType.name.lowercase(),
"status" to payment.status.name.lowercase(),
)
fun asPaymentList(arr: ReadableArray): List<Payment> {
val list = ArrayList<Payment>()
for (value in arr.toArrayList()) {
when (value) {
is ReadableMap -> list.add(asPayment(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asPrepareReceiveRequest(prepareReceiveRequest: ReadableMap): PrepareReceiveRequest? {
if (!validateMandatoryFields(
prepareReceiveRequest,
arrayOf(
"payerAmountSat",
),
)
) {
return null
}
val payerAmountSat = prepareReceiveRequest.getDouble("payerAmountSat").toULong()
return PrepareReceiveRequest(
payerAmountSat,
)
}
fun readableMapOf(prepareReceiveRequest: PrepareReceiveRequest): ReadableMap =
readableMapOf(
"payerAmountSat" to prepareReceiveRequest.payerAmountSat,
)
fun asPrepareReceiveRequestList(arr: ReadableArray): List<PrepareReceiveRequest> {
val list = ArrayList<PrepareReceiveRequest>()
for (value in arr.toArrayList()) {
when (value) {
is ReadableMap -> list.add(asPrepareReceiveRequest(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asPrepareReceiveResponse(prepareReceiveResponse: ReadableMap): PrepareReceiveResponse? {
if (!validateMandatoryFields(
prepareReceiveResponse,
arrayOf(
"payerAmountSat",
"feesSat",
),
)
) {
return null
}
val payerAmountSat = prepareReceiveResponse.getDouble("payerAmountSat").toULong()
val feesSat = prepareReceiveResponse.getDouble("feesSat").toULong()
return PrepareReceiveResponse(
payerAmountSat,
feesSat,
)
}
fun readableMapOf(prepareReceiveResponse: PrepareReceiveResponse): ReadableMap =
readableMapOf(
"payerAmountSat" to prepareReceiveResponse.payerAmountSat,
"feesSat" to prepareReceiveResponse.feesSat,
)
fun asPrepareReceiveResponseList(arr: ReadableArray): List<PrepareReceiveResponse> {
val list = ArrayList<PrepareReceiveResponse>()
for (value in arr.toArrayList()) {
when (value) {
is ReadableMap -> list.add(asPrepareReceiveResponse(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asPrepareSendRequest(prepareSendRequest: ReadableMap): PrepareSendRequest? {
if (!validateMandatoryFields(
prepareSendRequest,
arrayOf(
"invoice",
),
)
) {
return null
}
val invoice = prepareSendRequest.getString("invoice")!!
return PrepareSendRequest(
invoice,
)
}
fun readableMapOf(prepareSendRequest: PrepareSendRequest): ReadableMap =
readableMapOf(
"invoice" to prepareSendRequest.invoice,
)
fun asPrepareSendRequestList(arr: ReadableArray): List<PrepareSendRequest> {
val list = ArrayList<PrepareSendRequest>()
for (value in arr.toArrayList()) {
when (value) {
is ReadableMap -> list.add(asPrepareSendRequest(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asPrepareSendResponse(prepareSendResponse: ReadableMap): PrepareSendResponse? {
if (!validateMandatoryFields(
prepareSendResponse,
arrayOf(
"invoice",
"feesSat",
),
)
) {
return null
}
val invoice = prepareSendResponse.getString("invoice")!!
val feesSat = prepareSendResponse.getDouble("feesSat").toULong()
return PrepareSendResponse(
invoice,
feesSat,
)
}
fun readableMapOf(prepareSendResponse: PrepareSendResponse): ReadableMap =
readableMapOf(
"invoice" to prepareSendResponse.invoice,
"feesSat" to prepareSendResponse.feesSat,
)
fun asPrepareSendResponseList(arr: ReadableArray): List<PrepareSendResponse> {
val list = ArrayList<PrepareSendResponse>()
for (value in arr.toArrayList()) {
when (value) {
is ReadableMap -> list.add(asPrepareSendResponse(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asReceivePaymentResponse(receivePaymentResponse: ReadableMap): ReceivePaymentResponse? {
if (!validateMandatoryFields(
receivePaymentResponse,
arrayOf(
"id",
"invoice",
),
)
) {
return null
}
val id = receivePaymentResponse.getString("id")!!
val invoice = receivePaymentResponse.getString("invoice")!!
return ReceivePaymentResponse(
id,
invoice,
)
}
fun readableMapOf(receivePaymentResponse: ReceivePaymentResponse): ReadableMap =
readableMapOf(
"id" to receivePaymentResponse.id,
"invoice" to receivePaymentResponse.invoice,
)
fun asReceivePaymentResponseList(arr: ReadableArray): List<ReceivePaymentResponse> {
val list = ArrayList<ReceivePaymentResponse>()
for (value in arr.toArrayList()) {
when (value) {
is ReadableMap -> list.add(asReceivePaymentResponse(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asRestoreRequest(restoreRequest: ReadableMap): RestoreRequest? {
if (!validateMandatoryFields(
restoreRequest,
arrayOf(),
)
) {
return null
}
val backupPath = if (hasNonNullKey(restoreRequest, "backupPath")) restoreRequest.getString("backupPath") else null
return RestoreRequest(
backupPath,
)
}
fun readableMapOf(restoreRequest: RestoreRequest): ReadableMap =
readableMapOf(
"backupPath" to restoreRequest.backupPath,
)
fun asRestoreRequestList(arr: ReadableArray): List<RestoreRequest> {
val list = ArrayList<RestoreRequest>()
for (value in arr.toArrayList()) {
when (value) {
is ReadableMap -> list.add(asRestoreRequest(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asRouteHint(routeHint: ReadableMap): RouteHint? {
if (!validateMandatoryFields(
routeHint,
arrayOf(
"hops",
),
)
) {
return null
}
val hops = routeHint.getArray("hops")?.let { asRouteHintHopList(it) }!!
return RouteHint(
hops,
)
}
fun readableMapOf(routeHint: RouteHint): ReadableMap =
readableMapOf(
"hops" to readableArrayOf(routeHint.hops),
)
fun asRouteHintList(arr: ReadableArray): List<RouteHint> {
val list = ArrayList<RouteHint>()
for (value in arr.toArrayList()) {
when (value) {
is ReadableMap -> list.add(asRouteHint(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asRouteHintHop(routeHintHop: ReadableMap): RouteHintHop? {
if (!validateMandatoryFields(
routeHintHop,
arrayOf(
"srcNodeId",
"shortChannelId",
"feesBaseMsat",
"feesProportionalMillionths",
"cltvExpiryDelta",
),
)
) {
return null
}
val srcNodeId = routeHintHop.getString("srcNodeId")!!
val shortChannelId = routeHintHop.getDouble("shortChannelId").toULong()
val feesBaseMsat = routeHintHop.getInt("feesBaseMsat").toUInt()
val feesProportionalMillionths = routeHintHop.getInt("feesProportionalMillionths").toUInt()
val cltvExpiryDelta = routeHintHop.getDouble("cltvExpiryDelta").toULong()
val htlcMinimumMsat = if (hasNonNullKey(routeHintHop, "htlcMinimumMsat")) routeHintHop.getDouble("htlcMinimumMsat").toULong() else null
val htlcMaximumMsat = if (hasNonNullKey(routeHintHop, "htlcMaximumMsat")) routeHintHop.getDouble("htlcMaximumMsat").toULong() else null
return RouteHintHop(
srcNodeId,
shortChannelId,
feesBaseMsat,
feesProportionalMillionths,
cltvExpiryDelta,
htlcMinimumMsat,
htlcMaximumMsat,
)
}
fun readableMapOf(routeHintHop: RouteHintHop): ReadableMap =
readableMapOf(
"srcNodeId" to routeHintHop.srcNodeId,
"shortChannelId" to routeHintHop.shortChannelId,
"feesBaseMsat" to routeHintHop.feesBaseMsat,
"feesProportionalMillionths" to routeHintHop.feesProportionalMillionths,
"cltvExpiryDelta" to routeHintHop.cltvExpiryDelta,
"htlcMinimumMsat" to routeHintHop.htlcMinimumMsat,
"htlcMaximumMsat" to routeHintHop.htlcMaximumMsat,
)
fun asRouteHintHopList(arr: ReadableArray): List<RouteHintHop> {
val list = ArrayList<RouteHintHop>()
for (value in arr.toArrayList()) {
when (value) {
is ReadableMap -> list.add(asRouteHintHop(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asSendPaymentResponse(sendPaymentResponse: ReadableMap): SendPaymentResponse? {
if (!validateMandatoryFields(
sendPaymentResponse,
arrayOf(
"payment",
),
)
) {
return null
}
val payment = sendPaymentResponse.getMap("payment")?.let { asPayment(it) }!!
return SendPaymentResponse(
payment,
)
}
fun readableMapOf(sendPaymentResponse: SendPaymentResponse): ReadableMap =
readableMapOf(
"payment" to readableMapOf(sendPaymentResponse.payment),
)
fun asSendPaymentResponseList(arr: ReadableArray): List<SendPaymentResponse> {
val list = ArrayList<SendPaymentResponse>()
for (value in arr.toArrayList()) {
when (value) {
is ReadableMap -> list.add(asSendPaymentResponse(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asLiquidSdkEvent(liquidSdkEvent: ReadableMap): LiquidSdkEvent? {
val type = liquidSdkEvent.getString("type")
if (type == "paymentFailed") {
return LiquidSdkEvent.PaymentFailed(liquidSdkEvent.getMap("details")?.let { asPayment(it) }!!)
}
if (type == "paymentPending") {
return LiquidSdkEvent.PaymentPending(liquidSdkEvent.getMap("details")?.let { asPayment(it) }!!)
}
if (type == "paymentRefunded") {
return LiquidSdkEvent.PaymentRefunded(liquidSdkEvent.getMap("details")?.let { asPayment(it) }!!)
}
if (type == "paymentRefundPending") {
return LiquidSdkEvent.PaymentRefundPending(liquidSdkEvent.getMap("details")?.let { asPayment(it) }!!)
}
if (type == "paymentSucceed") {
return LiquidSdkEvent.PaymentSucceed(liquidSdkEvent.getMap("details")?.let { asPayment(it) }!!)
}
if (type == "paymentWaitingConfirmation") {
return LiquidSdkEvent.PaymentWaitingConfirmation(liquidSdkEvent.getMap("details")?.let { asPayment(it) }!!)
}
if (type == "synced") {
return LiquidSdkEvent.Synced
}
return null
}
fun readableMapOf(liquidSdkEvent: LiquidSdkEvent): ReadableMap? {
val map = Arguments.createMap()
when (liquidSdkEvent) {
is LiquidSdkEvent.PaymentFailed -> {
pushToMap(map, "type", "paymentFailed")
pushToMap(map, "details", readableMapOf(liquidSdkEvent.details))
}
is LiquidSdkEvent.PaymentPending -> {
pushToMap(map, "type", "paymentPending")
pushToMap(map, "details", readableMapOf(liquidSdkEvent.details))
}
is LiquidSdkEvent.PaymentRefunded -> {
pushToMap(map, "type", "paymentRefunded")
pushToMap(map, "details", readableMapOf(liquidSdkEvent.details))
}
is LiquidSdkEvent.PaymentRefundPending -> {
pushToMap(map, "type", "paymentRefundPending")
pushToMap(map, "details", readableMapOf(liquidSdkEvent.details))
}
is LiquidSdkEvent.PaymentSucceed -> {
pushToMap(map, "type", "paymentSucceed")
pushToMap(map, "details", readableMapOf(liquidSdkEvent.details))
}
is LiquidSdkEvent.PaymentWaitingConfirmation -> {
pushToMap(map, "type", "paymentWaitingConfirmation")
pushToMap(map, "details", readableMapOf(liquidSdkEvent.details))
}
is LiquidSdkEvent.Synced -> {
pushToMap(map, "type", "synced")
}
}
return map
}
fun asLiquidSdkEventList(arr: ReadableArray): List<LiquidSdkEvent> {
val list = ArrayList<LiquidSdkEvent>()
for (value in arr.toArrayList()) {
when (value) {
is ReadableMap -> list.add(asLiquidSdkEvent(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asNetwork(type: String): Network = Network.valueOf(camelToUpperSnakeCase(type))
fun asNetworkList(arr: ReadableArray): List<Network> {
val list = ArrayList<Network>()
for (value in arr.toArrayList()) {
when (value) {
is String -> list.add(asNetwork(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asPaymentState(type: String): PaymentState = PaymentState.valueOf(camelToUpperSnakeCase(type))
fun asPaymentStateList(arr: ReadableArray): List<PaymentState> {
val list = ArrayList<PaymentState>()
for (value in arr.toArrayList()) {
when (value) {
is String -> list.add(asPaymentState(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asPaymentType(type: String): PaymentType = PaymentType.valueOf(camelToUpperSnakeCase(type))
fun asPaymentTypeList(arr: ReadableArray): List<PaymentType> {
val list = ArrayList<PaymentType>()
for (value in arr.toArrayList()) {
when (value) {
is String -> list.add(asPaymentType(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun readableMapOf(vararg values: Pair<String, *>): ReadableMap {
val map = Arguments.createMap()
for ((key, value) in values) {
pushToMap(map, key, value)
}
return map
}
fun hasNonNullKey(
map: ReadableMap,
key: String,
): Boolean = map.hasKey(key) && !map.isNull(key)
fun validateMandatoryFields(
map: ReadableMap,
keys: Array<String>,
): Boolean {
for (k in keys) {
if (!hasNonNullKey(map, k)) return false
}
return true
}
fun pushToArray(
array: WritableArray,
value: Any?,
) {
when (value) {
null -> array.pushNull()
is Payment -> array.pushMap(readableMapOf(value))
is RouteHint -> array.pushMap(readableMapOf(value))
is RouteHintHop -> array.pushMap(readableMapOf(value))
is UByte -> array.pushInt(value.toInt())
is Array<*> -> array.pushArray(readableArrayOf(value.asIterable()))
is List<*> -> array.pushArray(readableArrayOf(value))
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
fun pushToMap(
map: WritableMap,
key: String,
value: Any?,
) {
when (value) {
null -> map.putNull(key)
is Boolean -> map.putBoolean(key, value)
is Byte -> map.putInt(key, value.toInt())
is Double -> map.putDouble(key, value)
is Int -> map.putInt(key, value)
is Long -> map.putDouble(key, value.toDouble())
is ReadableArray -> map.putArray(key, value)
is ReadableMap -> map.putMap(key, value)
is String -> map.putString(key, value)
is UByte -> map.putInt(key, value.toInt())
is UInt -> map.putInt(key, value.toInt())
is UShort -> map.putInt(key, value.toInt())
is ULong -> map.putDouble(key, value.toDouble())
is Array<*> -> map.putArray(key, readableArrayOf(value.asIterable()))
is List<*> -> map.putArray(key, readableArrayOf(value))
else -> throw LiquidSdkException.Generic("Unexpected type ${value::class.java.name} for key [$key]")
}
}
fun readableArrayOf(values: Iterable<*>?): ReadableArray {
val array = Arguments.createArray()
if (values != null) {
for (value in values) {
pushToArray(array, value)
}
}
return array
}
fun asUByteList(arr: ReadableArray): List<UByte> {
val list = ArrayList<UByte>()
for (value in arr.toArrayList()) {
when (value) {
is Double -> list.add(value.toInt().toUByte())
is Int -> list.add(value.toUByte())
is UByte -> list.add(value)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asStringList(arr: ReadableArray): List<String> {
val list = ArrayList<String>()
for (value in arr.toArrayList()) {
list.add(value.toString())
}
return list
}
fun errMissingMandatoryField(
fieldName: String,
typeName: String,
): String = "Missing mandatory field $fieldName for type $typeName"
fun errUnexpectedType(typeName: String): String = "Unexpected type $typeName"
fun errUnexpectedValue(fieldName: String): String = "Unexpected value for optional field $fieldName"
fun camelToUpperSnakeCase(str: String): String {
val pattern = "(?<=.)[A-Z]".toRegex()
return str.replace(pattern, "_$0").uppercase()
}

321
packages/react-native/android/src/main/java/com/breezliquidsdk/BreezLiquidSDKModule.kt
View File

@@ -1,321 +0,0 @@
package com.breezliquidsdk
import breez_liquid_sdk.*
import com.facebook.react.bridge.*
import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
import java.io.File
import java.util.*
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors
class BreezLiquidSDKModule(
reactContext: ReactApplicationContext,
) : ReactContextBaseJavaModule(reactContext) {
private lateinit var executor: ExecutorService
private var bindingLiquidSdk: BindingLiquidSdk? = null
companion object {
const val TAG = "RNBreezLiquidSDK"
}
override fun initialize() {
super.initialize()
executor = Executors.newFixedThreadPool(3)
}
override fun getName(): String = TAG
@Throws(LiquidSdkException::class)
fun getBindingLiquidSdk(): BindingLiquidSdk {
if (bindingLiquidSdk != null) {
return bindingLiquidSdk!!
}
throw LiquidSdkException.Generic("Not initialized")
}
@Throws(LiquidSdkException::class)
private fun ensureWorkingDir(workingDir: String) {
try {
val workingDirFile = File(workingDir)
if (!workingDirFile.exists() && !workingDirFile.mkdirs()) {
throw LiquidSdkException.Generic("Mandatory field workingDir must contain a writable directory")
}
} catch (e: SecurityException) {
throw LiquidSdkException.Generic("Mandatory field workingDir must contain a writable directory")
}
}
@ReactMethod
fun addListener(eventName: String) {}
@ReactMethod
fun removeListeners(count: Int) {}
@ReactMethod
fun defaultConfig(
network: String,
promise: Promise,
) {
executor.execute {
try {
val networkTmp = asNetwork(network)
val res = defaultConfig(networkTmp)
val workingDir = File(reactApplicationContext.filesDir.toString() + "/breezLiquidSdk")
res.workingDir = workingDir.absolutePath
promise.resolve(readableMapOf(res))
} catch (e: Exception) {
promise.reject(e.javaClass.simpleName.replace("Exception", "Error"), e.message, e)
}
}
}
@ReactMethod
fun parseInvoice(
invoice: String,
promise: Promise,
) {
executor.execute {
try {
val res = parseInvoice(invoice)
promise.resolve(readableMapOf(res))
} catch (e: Exception) {
promise.reject(e.javaClass.simpleName.replace("Exception", "Error"), e.message, e)
}
}
}
@ReactMethod
fun setLogger(promise: Promise) {
executor.execute {
try {
val emitter = reactApplicationContext.getJSModule(RCTDeviceEventEmitter::class.java)
setLogger(BreezLiquidSDKLogger(emitter))
promise.resolve(readableMapOf("status" to "ok"))
} catch (e: Exception) {
e.printStackTrace()
promise.reject(e.javaClass.simpleName.replace("Exception", "Error"), e.message, e)
}
}
}
@ReactMethod
fun connect(
req: ReadableMap,
promise: Promise,
) {
if (bindingLiquidSdk != null) {
promise.reject("Generic", "Already initialized")
return
}
executor.execute {
try {
var connectRequest =
asConnectRequest(req) ?: run { throw LiquidSdkException.Generic(errMissingMandatoryField("req", "ConnectRequest")) }
ensureWorkingDir(connectRequest.config.workingDir)
bindingLiquidSdk = connect(connectRequest)
promise.resolve(readableMapOf("status" to "ok"))
} catch (e: Exception) {
promise.reject(e.javaClass.simpleName.replace("Exception", "Error"), e.message, e)
}
}
}
@ReactMethod
fun addEventListener(promise: Promise) {
executor.execute {
try {
val emitter = reactApplicationContext.getJSModule(RCTDeviceEventEmitter::class.java)
var eventListener = BreezLiquidSDKEventListener(emitter)
val res = getBindingLiquidSdk().addEventListener(eventListener)
eventListener.setId(res)
promise.resolve(res)
} catch (e: Exception) {
promise.reject(e.javaClass.simpleName.replace("Exception", "Error"), e.message, e)
}
}
}
@ReactMethod
fun removeEventListener(
id: String,
promise: Promise,
) {
executor.execute {
try {
getBindingLiquidSdk().removeEventListener(id)
promise.resolve(readableMapOf("status" to "ok"))
} catch (e: Exception) {
promise.reject(e.javaClass.simpleName.replace("Exception", "Error"), e.message, e)
}
}
}
@ReactMethod
fun getInfo(
req: ReadableMap,
promise: Promise,
) {
executor.execute {
try {
val getInfoRequest =
asGetInfoRequest(req) ?: run { throw LiquidSdkException.Generic(errMissingMandatoryField("req", "GetInfoRequest")) }
val res = getBindingLiquidSdk().getInfo(getInfoRequest)
promise.resolve(readableMapOf(res))
} catch (e: Exception) {
promise.reject(e.javaClass.simpleName.replace("Exception", "Error"), e.message, e)
}
}
}
@ReactMethod
fun prepareSendPayment(
req: ReadableMap,
promise: Promise,
) {
executor.execute {
try {
val prepareSendRequest =
asPrepareSendRequest(req)
?: run { throw LiquidSdkException.Generic(errMissingMandatoryField("req", "PrepareSendRequest")) }
val res = getBindingLiquidSdk().prepareSendPayment(prepareSendRequest)
promise.resolve(readableMapOf(res))
} catch (e: Exception) {
promise.reject(e.javaClass.simpleName.replace("Exception", "Error"), e.message, e)
}
}
}
@ReactMethod
fun sendPayment(
req: ReadableMap,
promise: Promise,
) {
executor.execute {
try {
val prepareSendResponse =
asPrepareSendResponse(req)
?: run { throw LiquidSdkException.Generic(errMissingMandatoryField("req", "PrepareSendResponse")) }
val res = getBindingLiquidSdk().sendPayment(prepareSendResponse)
promise.resolve(readableMapOf(res))
} catch (e: Exception) {
promise.reject(e.javaClass.simpleName.replace("Exception", "Error"), e.message, e)
}
}
}
@ReactMethod
fun prepareReceivePayment(
req: ReadableMap,
promise: Promise,
) {
executor.execute {
try {
val prepareReceiveRequest =
asPrepareReceiveRequest(req)
?: run { throw LiquidSdkException.Generic(errMissingMandatoryField("req", "PrepareReceiveRequest")) }
val res = getBindingLiquidSdk().prepareReceivePayment(prepareReceiveRequest)
promise.resolve(readableMapOf(res))
} catch (e: Exception) {
promise.reject(e.javaClass.simpleName.replace("Exception", "Error"), e.message, e)
}
}
}
@ReactMethod
fun receivePayment(
req: ReadableMap,
promise: Promise,
) {
executor.execute {
try {
val prepareReceiveResponse =
asPrepareReceiveResponse(req)
?: run { throw LiquidSdkException.Generic(errMissingMandatoryField("req", "PrepareReceiveResponse")) }
val res = getBindingLiquidSdk().receivePayment(prepareReceiveResponse)
promise.resolve(readableMapOf(res))
} catch (e: Exception) {
promise.reject(e.javaClass.simpleName.replace("Exception", "Error"), e.message, e)
}
}
}
@ReactMethod
fun listPayments(promise: Promise) {
executor.execute {
try {
val res = getBindingLiquidSdk().listPayments()
promise.resolve(readableArrayOf(res))
} catch (e: Exception) {
promise.reject(e.javaClass.simpleName.replace("Exception", "Error"), e.message, e)
}
}
}
@ReactMethod
fun sync(promise: Promise) {
executor.execute {
try {
getBindingLiquidSdk().sync()
promise.resolve(readableMapOf("status" to "ok"))
} catch (e: Exception) {
promise.reject(e.javaClass.simpleName.replace("Exception", "Error"), e.message, e)
}
}
}
@ReactMethod
fun backup(
req: ReadableMap,
promise: Promise,
) {
executor.execute {
try {
val backupRequest =
asBackupRequest(req) ?: run { throw LiquidSdkException.Generic(errMissingMandatoryField("req", "BackupRequest")) }
getBindingLiquidSdk().backup(backupRequest)
promise.resolve(readableMapOf("status" to "ok"))
} catch (e: Exception) {
promise.reject(e.javaClass.simpleName.replace("Exception", "Error"), e.message, e)
}
}
}
@ReactMethod
fun restore(
req: ReadableMap,
promise: Promise,
) {
executor.execute {
try {
val restoreRequest =
asRestoreRequest(req) ?: run { throw LiquidSdkException.Generic(errMissingMandatoryField("req", "RestoreRequest")) }
getBindingLiquidSdk().restore(restoreRequest)
promise.resolve(readableMapOf("status" to "ok"))
} catch (e: Exception) {
promise.reject(e.javaClass.simpleName.replace("Exception", "Error"), e.message, e)
}
}
}
@ReactMethod
fun disconnect(promise: Promise) {
executor.execute {
try {
getBindingLiquidSdk().disconnect()
bindingLiquidSdk = null
promise.resolve(readableMapOf("status" to "ok"))
} catch (e: Exception) {
promise.reject(e.javaClass.simpleName.replace("Exception", "Error"), e.message, e)
}
}
}
}

1095
packages/react-native/ios/BreezLiquidSDKMapper.swift
View File

File diff suppressed because it is too large Load Diff

97
packages/react-native/ios/RNBreezLiquidSDK.m
View File

@@ -1,97 +0,0 @@
#import <React/RCTBridgeModule.h>
#import <React/RCTEventEmitter.h>
@interface RCT_EXTERN_MODULE(RNBreezLiquidSDK, RCTEventEmitter)
RCT_EXTERN_METHOD(
defaultConfig: (NSString*)network
resolve: (RCTPromiseResolveBlock)resolve
reject: (RCTPromiseRejectBlock)reject
)
RCT_EXTERN_METHOD(
parseInvoice: (NSString*)invoice
resolve: (RCTPromiseResolveBlock)resolve
reject: (RCTPromiseRejectBlock)reject
)
RCT_EXTERN_METHOD(
setLogger: (RCTPromiseResolveBlock)resolve
reject: (RCTPromiseRejectBlock)reject
)
RCT_EXTERN_METHOD(
connect: (NSDictionary*)req
resolve: (RCTPromiseResolveBlock)resolve
reject: (RCTPromiseRejectBlock)reject
)
RCT_EXTERN_METHOD(
addEventListener: (RCTPromiseResolveBlock)resolve
reject: (RCTPromiseRejectBlock)reject
)
RCT_EXTERN_METHOD(
removeEventListener: (NSString*)id
resolve: (RCTPromiseResolveBlock)resolve
reject: (RCTPromiseRejectBlock)reject
)
RCT_EXTERN_METHOD(
getInfo: (NSDictionary*)req
resolve: (RCTPromiseResolveBlock)resolve
reject: (RCTPromiseRejectBlock)reject
)
RCT_EXTERN_METHOD(
prepareSendPayment: (NSDictionary*)req
resolve: (RCTPromiseResolveBlock)resolve
reject: (RCTPromiseRejectBlock)reject
)
RCT_EXTERN_METHOD(
sendPayment: (NSDictionary*)req
resolve: (RCTPromiseResolveBlock)resolve
reject: (RCTPromiseRejectBlock)reject
)
RCT_EXTERN_METHOD(
prepareReceivePayment: (NSDictionary*)req
resolve: (RCTPromiseResolveBlock)resolve
reject: (RCTPromiseRejectBlock)reject
)
RCT_EXTERN_METHOD(
receivePayment: (NSDictionary*)req
resolve: (RCTPromiseResolveBlock)resolve
reject: (RCTPromiseRejectBlock)reject
)
RCT_EXTERN_METHOD(
listPayments: (RCTPromiseResolveBlock)resolve
reject: (RCTPromiseRejectBlock)reject
)
RCT_EXTERN_METHOD(
sync: (RCTPromiseResolveBlock)resolve
reject: (RCTPromiseRejectBlock)reject
)
RCT_EXTERN_METHOD(
backup: (NSDictionary*)req
resolve: (RCTPromiseResolveBlock)resolve
reject: (RCTPromiseRejectBlock)reject
)
RCT_EXTERN_METHOD(
restore: (NSDictionary*)req
resolve: (RCTPromiseResolveBlock)resolve
reject: (RCTPromiseRejectBlock)reject
)
RCT_EXTERN_METHOD(
disconnect: (RCTPromiseResolveBlock)resolve
reject: (RCTPromiseRejectBlock)reject
)
@end

266
packages/react-native/ios/RNBreezLiquidSDK.swift
View File

@@ -1,266 +0,0 @@
import BreezLiquidSDK
import Foundation
@objc(RNBreezLiquidSDK)
class RNBreezLiquidSDK: RCTEventEmitter {
static let TAG: String = "BreezLiquidSDK"
public static var emitter: RCTEventEmitter!
public static var hasListeners: Bool = false
public static var supportedEvents: [String] = ["breezLiquidSdkLog"]
private var bindingLiquidSdk: BindingLiquidSdk!
static var breezLiquidSdkDirectory: URL {
let applicationDirectory = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first!
let breezLiquidSdkDirectory = applicationDirectory.appendingPathComponent("breezLiquidSdk", isDirectory: true)
if !FileManager.default.fileExists(atPath: breezLiquidSdkDirectory.path) {
try! FileManager.default.createDirectory(atPath: breezLiquidSdkDirectory.path, withIntermediateDirectories: true)
}
return breezLiquidSdkDirectory
}
override init() {
super.init()
RNBreezLiquidSDK.emitter = self
}
@objc
override static func moduleName() -> String! {
TAG
}
static func addSupportedEvent(name: String) {
RNBreezLiquidSDK.supportedEvents.append(name)
}
override func supportedEvents() -> [String]! {
return RNBreezLiquidSDK.supportedEvents
}
override func startObserving() {
RNBreezLiquidSDK.hasListeners = true
}
override func stopObserving() {
RNBreezLiquidSDK.hasListeners = false
}
@objc
override static func requiresMainQueueSetup() -> Bool {
return false
}
func getBindingLiquidSdk() throws -> BindingLiquidSdk {
if bindingLiquidSdk != nil {
return bindingLiquidSdk
}
throw LiquidSdkError.Generic(message: "Not initialized")
}
private func ensureWorkingDir(workingDir: String) throws {
do {
if !FileManager.default.fileExists(atPath: workingDir) {
try FileManager.default.createDirectory(atPath: workingDir, withIntermediateDirectories: true)
}
} catch {
throw LiquidSdkError.Generic(message: "Mandatory field workingDir must contain a writable directory")
}
}
@objc(defaultConfig:resolve:reject:)
func defaultConfig(_ network: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
do {
let networkTmp = try BreezLiquidSDKMapper.asNetwork(network: network)
var res = BreezLiquidSDK.defaultConfig(network: networkTmp)
res.workingDir = RNBreezLiquidSDK.breezLiquidSdkDirectory.path
resolve(BreezLiquidSDKMapper.dictionaryOf(config: res))
} catch let err {
rejectErr(err: err, reject: reject)
}
}
@objc(parseInvoice:resolve:reject:)
func parseInvoice(_ invoice: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
do {
var res = try BreezLiquidSDK.parseInvoice(invoice: invoice)
resolve(BreezLiquidSDKMapper.dictionaryOf(lnInvoice: res))
} catch let err {
rejectErr(err: err, reject: reject)
}
}
@objc(setLogger:reject:)
func setLogger(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
do {
try BreezLiquidSDK.setLogger(Logger: BreezLiquidSDKLogger())
resolve(["status": "ok"])
} catch let err {
rejectErr(err: err, reject: reject)
}
}
@objc(connect:resolve:reject:)
func connect(_ req: [String: Any], resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
if bindingLiquidSdk != nil {
reject("Generic", "Already initialized", nil)
return
}
do {
var connectRequest = try BreezLiquidSDKMapper.asConnectRequest(connectRequest: req)
try ensureWorkingDir(workingDir: connectRequest.config.workingDir)
bindingLiquidSdk = try BreezLiquidSDK.connect(req: connectRequest)
resolve(["status": "ok"])
} catch let err {
rejectErr(err: err, reject: reject)
}
}
@objc(addEventListener:reject:)
func addEventListener(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
do {
var eventListener = BreezLiquidSDKEventListener()
var res = try getBindingLiquidSdk().addEventListener(listener: eventListener)
eventListener.setId(id: res)
resolve(res)
} catch let err {
rejectErr(err: err, reject: reject)
}
}
@objc(removeEventListener:resolve:reject:)
func removeEventListener(_ id: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
do {
try getBindingLiquidSdk().removeEventListener(id: id)
resolve(["status": "ok"])
} catch let err {
rejectErr(err: err, reject: reject)
}
}
@objc(getInfo:resolve:reject:)
func getInfo(_ req: [String: Any], resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
do {
let getInfoRequest = try BreezLiquidSDKMapper.asGetInfoRequest(getInfoRequest: req)
var res = try getBindingLiquidSdk().getInfo(req: getInfoRequest)
resolve(BreezLiquidSDKMapper.dictionaryOf(getInfoResponse: res))
} catch let err {
rejectErr(err: err, reject: reject)
}
}
@objc(prepareSendPayment:resolve:reject:)
func prepareSendPayment(_ req: [String: Any], resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
do {
let prepareSendRequest = try BreezLiquidSDKMapper.asPrepareSendRequest(prepareSendRequest: req)
var res = try getBindingLiquidSdk().prepareSendPayment(req: prepareSendRequest)
resolve(BreezLiquidSDKMapper.dictionaryOf(prepareSendResponse: res))
} catch let err {
rejectErr(err: err, reject: reject)
}
}
@objc(sendPayment:resolve:reject:)
func sendPayment(_ req: [String: Any], resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
do {
let prepareSendResponse = try BreezLiquidSDKMapper.asPrepareSendResponse(prepareSendResponse: req)
var res = try getBindingLiquidSdk().sendPayment(req: prepareSendResponse)
resolve(BreezLiquidSDKMapper.dictionaryOf(sendPaymentResponse: res))
} catch let err {
rejectErr(err: err, reject: reject)
}
}
@objc(prepareReceivePayment:resolve:reject:)
func prepareReceivePayment(_ req: [String: Any], resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
do {
let prepareReceiveRequest = try BreezLiquidSDKMapper.asPrepareReceiveRequest(prepareReceiveRequest: req)
var res = try getBindingLiquidSdk().prepareReceivePayment(req: prepareReceiveRequest)
resolve(BreezLiquidSDKMapper.dictionaryOf(prepareReceiveResponse: res))
} catch let err {
rejectErr(err: err, reject: reject)
}
}
@objc(receivePayment:resolve:reject:)
func receivePayment(_ req: [String: Any], resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
do {
let prepareReceiveResponse = try BreezLiquidSDKMapper.asPrepareReceiveResponse(prepareReceiveResponse: req)
var res = try getBindingLiquidSdk().receivePayment(req: prepareReceiveResponse)
resolve(BreezLiquidSDKMapper.dictionaryOf(receivePaymentResponse: res))
} catch let err {
rejectErr(err: err, reject: reject)
}
}
@objc(listPayments:reject:)
func listPayments(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
do {
var res = try getBindingLiquidSdk().listPayments()
resolve(BreezLiquidSDKMapper.arrayOf(paymentList: res))
} catch let err {
rejectErr(err: err, reject: reject)
}
}
@objc(sync:reject:)
func sync(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
do {
try getBindingLiquidSdk().sync()
resolve(["status": "ok"])
} catch let err {
rejectErr(err: err, reject: reject)
}
}
@objc(backup:resolve:reject:)
func backup(_ req: [String: Any], resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
do {
let backupRequest = try BreezLiquidSDKMapper.asBackupRequest(backupRequest: req)
try getBindingLiquidSdk().backup(req: backupRequest)
resolve(["status": "ok"])
} catch let err {
rejectErr(err: err, reject: reject)
}
}
@objc(restore:resolve:reject:)
func restore(_ req: [String: Any], resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
do {
let restoreRequest = try BreezLiquidSDKMapper.asRestoreRequest(restoreRequest: req)
try getBindingLiquidSdk().restore(req: restoreRequest)
resolve(["status": "ok"])
} catch let err {
rejectErr(err: err, reject: reject)
}
}
@objc(disconnect:reject:)
func disconnect(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
do {
try getBindingLiquidSdk().disconnect()
bindingLiquidSdk = nil
resolve(["status": "ok"])
} catch let err {
rejectErr(err: err, reject: reject)
}
}
func rejectErr(err: Error, reject: @escaping RCTPromiseRejectBlock) {
var errorName = "Generic"
var message = "\(err)"
if let errAssociated = Mirror(reflecting: err).children.first {
errorName = errAssociated.label ?? errorName
if let associatedMessage = Mirror(reflecting: errAssociated.value).children.first {
message = associatedMessage.value as! String
}
}
reject(errorName, message, err)
}
}