mirror of
https://github.com/aljazceru/breez-sdk-liquid.git
synced 2025-12-19 06:54:25 +01:00
remove old files
This commit is contained in:
Roei Erez
@@ -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()
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -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
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user