diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 1a70ea03f..9a0bf1356 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -25,3 +25,5 @@ jobs: - name: Check formatting if: matrix.check-fmt run: rustup component add rustfmt && cargo fmt --all -- --check + - name: Test on Rust ${{ matrix.toolchain }} + run: cargo test diff --git a/.gitignore b/.gitignore index 088ba6ba7..2acdc0ab4 100644 --- a/.gitignore +++ b/.gitignore @@ -8,3 +8,7 @@ Cargo.lock # These are backup files generated by rustfmt **/*.rs.bk + +*.dylib + +ldk_node.kt diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 000000000..26d33521a --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml new file mode 100644 index 000000000..1d9864d6f --- /dev/null +++ b/.idea/codeStyles/Project.xml @@ -0,0 +1,21 @@ + + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/codeStyles/codeStyleConfig.xml b/.idea/codeStyles/codeStyleConfig.xml new file mode 100644 index 000000000..a55e7a179 --- /dev/null +++ b/.idea/codeStyles/codeStyleConfig.xml @@ -0,0 +1,5 @@ + + + + \ No newline at end of file diff --git a/.idea/ldk-node.iml b/.idea/ldk-node.iml new file mode 100644 index 000000000..9b4cf845b --- /dev/null +++ b/.idea/ldk-node.iml @@ -0,0 +1,12 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 000000000..5a0adcddb --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 000000000..830674470 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/Cargo.toml b/Cargo.toml index d996a65ec..1ca122c18 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,30 +1,66 @@ [package] -name = "ldk-lite" +name = "ldk-node" version = "0.1.0" authors = ["Elias Rohrer "] license = "MIT OR Apache-2.0" edition = "2018" +description = "A ready-to-go node implementation based on LDK." # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html +[lib] +crate-type = ["staticlib", "cdylib"] +name = "ldk_node" + [dependencies] -lightning = { version = "0.0.110", features = ["max_level_trace", "std"] } -lightning-invoice = { version = "0.18" } -lightning-net-tokio = { version = "0.0.110" } -lightning-persister = { version = "0.0.110" } -lightning-background-processor = { version = "0.0.110" } -lightning-rapid-gossip-sync = { version = "0.0.110" } +#lightning = { version = "0.0.112", features = ["max_level_trace", "std"] } +#lightning-invoice = { version = "0.20" } +#lightning-net-tokio = { version = "0.0.112" } +#lightning-persister = { version = "0.0.112" } +#lightning-background-processor = { version = "0.0.112" } +#lightning-rapid-gossip-sync = { version = "0.0.112" } + +#lightning = { git = "https://github.com/lightningdevkit/rust-lightning", branch="main", features = ["max_level_trace", "std"] } +#lightning-invoice = { git = "https://github.com/lightningdevkit/rust-lightning", branch="main" } +#lightning-net-tokio = { git = "https://github.com/lightningdevkit/rust-lightning", branch="main" } +#lightning-persister = { git = "https://github.com/lightningdevkit/rust-lightning", branch="main" } +#lightning-background-processor = { git = "https://github.com/lightningdevkit/rust-lightning", branch="main" } +#lightning-rapid-gossip-sync = { git = "https://github.com/lightningdevkit/rust-lightning", branch="main" } + +lightning = { git = "https://github.com/tnull/rust-lightning", branch="2022-11-add-transaction-sync-crate", features = ["max_level_trace", "std"] } +lightning-invoice = { git = "https://github.com/tnull/rust-lightning", branch="2022-11-add-transaction-sync-crate" } +lightning-net-tokio = { git = "https://github.com/tnull/rust-lightning", branch="2022-11-add-transaction-sync-crate" } +lightning-persister = { git = "https://github.com/tnull/rust-lightning", branch="2022-11-add-transaction-sync-crate" } +lightning-background-processor = { git = "https://github.com/tnull/rust-lightning", branch="2022-11-add-transaction-sync-crate" } +lightning-rapid-gossip-sync = { git = "https://github.com/tnull/rust-lightning", branch="2022-11-add-transaction-sync-crate" } +lightning-transaction-sync = { git = "https://github.com/tnull/rust-lightning", branch="2022-11-add-transaction-sync-crate", features = ["esplora-async"] } -#bdk = "0.20.0" -bdk = { git = "https://github.com/tnull/bdk", branch="feat/use-external-esplora-client", features = ["use-esplora-ureq", "key-value-db"]} -bitcoin = "0.28.1" +#lightning = { path = "../rust-lightning/lightning", features = ["max_level_trace", "std"] } +#lightning-invoice = { path = "../rust-lightning/lightning-invoice" } +#lightning-net-tokio = { path = "../rust-lightning/lightning-net-tokio" } +#lightning-persister = { path = "../rust-lightning/lightning-persister" } +#lightning-background-processor = { path = "../rust-lightning/lightning-background-processor" } +#lightning-rapid-gossip-sync = { path = "../rust-lightning/lightning-rapid-gossip-sync" } +#lightning-transaction-sync = { path = "../rust-lightning/lightning-transaction-sync", features = ["esplora-async"] } + +bdk = { version = "0.26.0", default-features = false, features = ["async-interface", "use-esplora-async", "key-value-db"]} +bitcoin = "0.29.2" rand = "0.8.5" chrono = "0.4" futures = "0.3" serde_json = { version = "1.0" } -tokio = { version = "1", features = [ "io-util", "macros", "rt", "rt-multi-thread", "sync", "net", "time" ] } +tokio = { version = "1", features = [ "full" ] } +uniffi = { version = "0.21.0", features = ["builtin-bindgen"] } +uniffi_macros = { version = "0.21.0", features = ["builtin-bindgen"] } + +[dev-dependencies] +electrsd = { version = "0.22.0", features = ["legacy", "esplora_a33e97e1", "bitcoind_23_0"] } +electrum-client = "0.12.0" +once_cell = "1.16.0" +[build-dependencies] +uniffi_build = "0.21.0" [profile.release] panic = "abort" diff --git a/README.md b/README.md index 70026985e..dd5914b46 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,31 @@ # ldk-lite A Simplified API for LDK. + +## Build and publish to local Maven repository +```shell +source uniffi_bindgen_generate_kotlin.sh +cd ldk-node-jvm +./gradlew publishToMavenLocal +``` + +## How to Use +To use the Kotlin language bindings for [`ldk-node`] in your JVM project, add the following to your gradle dependencies: +```kotlin +repositories { + mavenCentral() +} + +dependencies { + implementation("org.ldk:ldk-node:0.0.1") +} +``` + +You may then import and use the `org.ldk_node` library in your Kotlin code. For example: +```kotlin +import uniffi.ldk_node.Builder +import uniffi.ldk_node.Node + +fun main() { + val node: Node = Builder().build() +} +``` diff --git a/build.rs b/build.rs new file mode 100644 index 000000000..2bd473cd6 --- /dev/null +++ b/build.rs @@ -0,0 +1,3 @@ +fn main() { + uniffi_build::generate_scaffolding("uniffi/ldk_node.udl").unwrap(); +} diff --git a/ldk-node-jvm/.gitattributes b/ldk-node-jvm/.gitattributes new file mode 100644 index 000000000..00a51aff5 --- /dev/null +++ b/ldk-node-jvm/.gitattributes @@ -0,0 +1,6 @@ +# +# https://help.github.com/articles/dealing-with-line-endings/ +# +# These are explicitly windows files and should use crlf +*.bat text eol=crlf + diff --git a/ldk-node-jvm/.gitignore b/ldk-node-jvm/.gitignore new file mode 100644 index 000000000..67c4583a2 --- /dev/null +++ b/ldk-node-jvm/.gitignore @@ -0,0 +1,7 @@ +# Ignore Gradle project-specific cache directory +.gradle + +# Ignore Gradle build output directory +build + +.idea/ diff --git a/ldk-node-jvm/gradle.properties b/ldk-node-jvm/gradle.properties new file mode 100644 index 000000000..125e7284f --- /dev/null +++ b/ldk-node-jvm/gradle.properties @@ -0,0 +1 @@ +libraryVersion=0.0.2 diff --git a/ldk-node-jvm/gradle/wrapper/gradle-wrapper.jar b/ldk-node-jvm/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 000000000..41d9927a4 Binary files /dev/null and b/ldk-node-jvm/gradle/wrapper/gradle-wrapper.jar differ diff --git a/ldk-node-jvm/gradle/wrapper/gradle-wrapper.properties b/ldk-node-jvm/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 000000000..00e33edef --- /dev/null +++ b/ldk-node-jvm/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,5 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.1-bin.zip +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/ldk-node-jvm/gradlew b/ldk-node-jvm/gradlew new file mode 100755 index 000000000..1b6c78733 --- /dev/null +++ b/ldk-node-jvm/gradlew @@ -0,0 +1,234 @@ +#!/bin/sh + +# +# Copyright © 2015-2021 the original authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +############################################################################## +# +# Gradle start up script for POSIX generated by Gradle. +# +# Important for running: +# +# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is +# noncompliant, but you have some other compliant shell such as ksh or +# bash, then to run this script, type that shell name before the whole +# command line, like: +# +# ksh Gradle +# +# Busybox and similar reduced shells will NOT work, because this script +# requires all of these POSIX shell features: +# * functions; +# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», +# «${var#prefix}», «${var%suffix}», and «$( cmd )»; +# * compound commands having a testable exit status, especially «case»; +# * various built-in commands including «command», «set», and «ulimit». +# +# Important for patching: +# +# (2) This script targets any POSIX shell, so it avoids extensions provided +# by Bash, Ksh, etc; in particular arrays are avoided. +# +# The "traditional" practice of packing multiple parameters into a +# space-separated string is a well documented source of bugs and security +# problems, so this is (mostly) avoided, by progressively accumulating +# options in "$@", and eventually passing that to Java. +# +# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, +# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; +# see the in-line comments for details. +# +# There are tweaks for specific operating systems such as AIX, CygWin, +# Darwin, MinGW, and NonStop. +# +# (3) This script is generated from the Groovy template +# https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# within the Gradle project. +# +# You can find Gradle at https://github.com/gradle/gradle/. +# +############################################################################## + +# Attempt to set APP_HOME + +# Resolve links: $0 may be a link +app_path=$0 + +# Need this for daisy-chained symlinks. +while + APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path + [ -h "$app_path" ] +do + ls=$( ls -ld "$app_path" ) + link=${ls#*' -> '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac +done + +APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit + +APP_NAME="Gradle" +APP_BASE_NAME=${0##*/} + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD=maximum + +warn () { + echo "$*" +} >&2 + +die () { + echo + echo "$*" + echo + exit 1 +} >&2 + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD=$JAVA_HOME/jre/sh/java + else + JAVACMD=$JAVA_HOME/bin/java + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD=java + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" + esac +fi + +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg + done +fi + +# Collect all arguments for the java command; +# * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of +# shell script including quotes and variable substitutions, so put them in +# double quotes to make sure that they get re-expanded; and +# * put everything else in single quotes, so that it's not re-expanded. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -classpath "$CLASSPATH" \ + org.gradle.wrapper.GradleWrapperMain \ + "$@" + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' + +exec "$JAVACMD" "$@" diff --git a/ldk-node-jvm/gradlew.bat b/ldk-node-jvm/gradlew.bat new file mode 100644 index 000000000..107acd32c --- /dev/null +++ b/ldk-node-jvm/gradlew.bat @@ -0,0 +1,89 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto execute + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/ldk-node-jvm/lib/build.gradle.kts b/ldk-node-jvm/lib/build.gradle.kts new file mode 100644 index 000000000..2903e0367 --- /dev/null +++ b/ldk-node-jvm/lib/build.gradle.kts @@ -0,0 +1,100 @@ +import org.gradle.api.tasks.testing.logging.TestExceptionFormat.* +import org.gradle.api.tasks.testing.logging.TestLogEvent.* + +// library version is defined in gradle.properties +val libraryVersion: String by project + +plugins { + id("org.jetbrains.kotlin.jvm") version "1.5.31" + id("java-library") + id("maven-publish") +} + +repositories { + mavenCentral() +} + +java { + sourceCompatibility = JavaVersion.VERSION_1_8 + targetCompatibility = JavaVersion.VERSION_1_8 + withSourcesJar() + withJavadocJar() +} + +tasks.withType { + useJUnitPlatform() + + testLogging { + events(PASSED, SKIPPED, FAILED, STANDARD_OUT, STANDARD_ERROR) + exceptionFormat = FULL + showExceptions = true + showCauses = true + showStackTraces = true + } +} + +dependencies { + // Align versions of all Kotlin components + implementation(platform("org.jetbrains.kotlin:kotlin-bom")) + + // Use the Kotlin JDK 8 standard library. + implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8") + + implementation("net.java.dev.jna:jna:5.8.0") +} + +afterEvaluate { + publishing { + publications { + create("maven") { + groupId = "org.ldk" + artifactId = "ldk-node" + version = libraryVersion + + from(components["java"]) + pom { + name.set("ldk-node") + description.set("Lightning Dev Kit Node language bindings for Kotlin.") + url.set("https://lightningdevkit.org") + licenses { + license { + name.set("APACHE 2.0") + url.set("https://github.com/bitcoindevkit/bdk/blob/master/LICENSE-APACHE") + } + license { + name.set("MIT") + url.set("https://github.com/bitcoindevkit/bdk/blob/master/LICENSE-MIT") + } + } + developers { + developer { + id.set("") + name.set("") + email.set("") + } + developer { + id.set("") + name.set("") + email.set("") + } + } + scm { + connection.set("scm:git:github.com/lightningdevkit/ldk-node.git") + developerConnection.set("scm:git:ssh://github.com/lightningdevkit/ldk-node.git") + url.set("https://github.com/lightningdevkit/ldk-node/tree/master") + } + } + } + } + } +} + +testing { + suites { + // Configure the built-in test suite + val test by getting(JvmTestSuite::class) { + // Use Kotlin Test test framework + useKotlinTest() + } + } +} diff --git a/ldk-node-jvm/lib/src/test/kotlin/ldk/node/LibraryTest.kt b/ldk-node-jvm/lib/src/test/kotlin/ldk/node/LibraryTest.kt new file mode 100644 index 000000000..3914cb939 --- /dev/null +++ b/ldk-node-jvm/lib/src/test/kotlin/ldk/node/LibraryTest.kt @@ -0,0 +1,14 @@ +/* + * This Kotlin source file was generated by the Gradle 'init' task. + */ +package ldk.node + +import kotlin.test.Test +import kotlin.test.assertTrue + +class LibraryTest { + @Test fun someLibraryMethodReturnsTrue() { + val classUnderTest = Library() + assertTrue(classUnderTest.someLibraryMethod(), "someLibraryMethod should return 'true'") + } +} diff --git a/ldk-node-jvm/settings.gradle.kts b/ldk-node-jvm/settings.gradle.kts new file mode 100644 index 000000000..75e57139a --- /dev/null +++ b/ldk-node-jvm/settings.gradle.kts @@ -0,0 +1,2 @@ +rootProject.name = "ldk-node-jvm" +include("lib") diff --git a/src/error.rs b/src/error.rs index e3b34613a..4f6ddd06f 100644 --- a/src/error.rs +++ b/src/error.rs @@ -1,130 +1,89 @@ -use bdk::blockchain::esplora; -use lightning::ln::msgs; -use lightning::util::errors; -use lightning_invoice::payment; use std::fmt; -use std::io; -use std::time; #[derive(Debug)] /// An error that possibly needs to be handled by the user. -pub enum LdkLiteError { - /// Returned when trying to start LdkLite while it is already running. +pub enum Error { + /// Returned when trying to start [`crate::Node`] while it is already running. AlreadyRunning, - /// Returned when trying to stop LdkLite while it is not running. + /// Returned when trying to stop [`crate::Node`] while it is not running. NotRunning, /// The funding transaction could not be created. FundingTxCreationFailed, /// A network connection has been closed. ConnectionFailed, + /// The given address is invalid. + AddressInvalid, + /// The given public key is invalid. + PublicKeyInvalid, + /// The given payment hash is invalid. + PaymentHashInvalid, /// Payment of the given invoice has already been intiated. NonUniquePaymentHash, + /// The given invoice is invalid. + InvoiceInvalid, + /// Invoice creation failed. + InvoiceCreationFailed, + /// The given channel ID is invalid. + ChannelIdInvalid, + /// No route for the given target could be found. + RoutingFailed, /// A given peer info could not be parsed. - PeerInfoParse(&'static str), - /// A wrapped LDK `APIError` - LdkApi(errors::APIError), - /// A wrapped LDK `DecodeError` - LdkDecode(msgs::DecodeError), - /// A wrapped LDK `PaymentError` - LdkPayment(payment::PaymentError), - /// A wrapped LDK `SignOrCreationError` - LdkInvoiceCreation(lightning_invoice::SignOrCreationError), - /// A wrapped BDK error - Bdk(bdk::Error), - /// A wrapped `EsploraError` - Esplora(esplora::EsploraError), - /// A wrapped `Bip32` error - Bip32(bitcoin::util::bip32::Error), - /// A wrapped `std::io::Error` - StdIo(io::Error), - /// A wrapped `SystemTimeError` - StdTime(time::SystemTimeError), + PeerInfoParseFailed, + /// A channel could not be opened. + ChannelCreationFailed, + /// A channel could not be closed. + ChannelClosingFailed, + /// Persistence failed. + PersistenceFailed, + /// A wallet operation failed. + WalletOperationFailed, + /// A siging operation failed. + WalletSigningFailed, + /// A transaction sync operation failed. + TxSyncFailed, } -impl fmt::Display for LdkLiteError { +impl fmt::Display for Error { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { - LdkLiteError::AlreadyRunning => write!(f, "LDKLite is already running."), - LdkLiteError::NotRunning => write!(f, "LDKLite is not running."), - LdkLiteError::FundingTxCreationFailed => { - write!(f, "the funding transaction could not be created") - } - LdkLiteError::ConnectionFailed => write!(f, "network connection closed"), - LdkLiteError::NonUniquePaymentHash => write!(f, "an invoice must not get payed twice."), - LdkLiteError::PeerInfoParse(ref e) => { - write!(f, "given peer info could not be parsed: {}", e) - } - LdkLiteError::LdkDecode(ref e) => write!(f, "LDK decode error: {}", e), - LdkLiteError::LdkApi(ref e) => write!(f, "LDK API error: {:?}", e), - LdkLiteError::LdkPayment(ref e) => write!(f, "LDK payment error: {:?}", e), - LdkLiteError::LdkInvoiceCreation(ref e) => { - write!(f, "LDK invoice sign or creation error: {:?}", e) - } - LdkLiteError::Bdk(ref e) => write!(f, "BDK error: {}", e), - LdkLiteError::Esplora(ref e) => write!(f, "Esplora error: {}", e), - LdkLiteError::Bip32(ref e) => write!(f, "Bitcoin error: {}", e), - LdkLiteError::StdIo(ref e) => write!(f, "IO error: {}", e), - LdkLiteError::StdTime(ref e) => write!(f, "time error: {}", e), + Self::AlreadyRunning => write!(f, "Node is already running."), + Self::NotRunning => write!(f, "Node is not running."), + Self::FundingTxCreationFailed => write!(f, "Funding transaction could not be created."), + Self::ConnectionFailed => write!(f, "Network connection closed."), + Self::AddressInvalid => write!(f, "The given address is invalid."), + Self::PublicKeyInvalid => write!(f, "The given public key is invalid."), + Self::PaymentHashInvalid => write!(f, "The given payment hash is invalid."), + Self::NonUniquePaymentHash => write!(f, "An invoice must not get payed twice."), + Self::InvoiceInvalid => write!(f, "The given invoice is invalid."), + Self::InvoiceCreationFailed => write!(f, "Failed to create invoice."), + Self::ChannelIdInvalid => write!(f, "The given channel ID is invalid."), + Self::RoutingFailed => write!(f, "Failed to find route."), + Self::PeerInfoParseFailed => write!(f, "Failed to parse the given peer information."), + Self::ChannelCreationFailed => write!(f, "Failed to create channel."), + Self::ChannelClosingFailed => write!(f, "Failed to close channel."), + Self::PersistenceFailed => write!(f, "Failed to persist data."), + Self::WalletOperationFailed => write!(f, "Failed to conduct wallet operation."), + Self::WalletSigningFailed => write!(f, "Failed to sign given transaction."), + Self::TxSyncFailed => write!(f, "Failed to sync transactions."), } } } -impl From for LdkLiteError { - fn from(e: errors::APIError) -> Self { - Self::LdkApi(e) - } -} +impl std::error::Error for Error {} -impl From for LdkLiteError { - fn from(e: msgs::DecodeError) -> Self { - Self::LdkDecode(e) - } -} - -impl From for LdkLiteError { - fn from(e: payment::PaymentError) -> Self { - Self::LdkPayment(e) - } -} - -impl From for LdkLiteError { - fn from(e: lightning_invoice::SignOrCreationError) -> Self { - Self::LdkInvoiceCreation(e) - } -} - -impl From for LdkLiteError { +impl From for Error { fn from(e: bdk::Error) -> Self { - Self::Bdk(e) - } -} - -impl From for LdkLiteError { - fn from(e: bdk::sled::Error) -> Self { - Self::Bdk(bdk::Error::Sled(e)) - } -} - -impl From for LdkLiteError { - fn from(e: bitcoin::util::bip32::Error) -> Self { - Self::Bip32(e) - } -} - -impl From for LdkLiteError { - fn from(e: io::Error) -> Self { - Self::StdIo(e) - } -} - -impl From for LdkLiteError { - fn from(e: time::SystemTimeError) -> Self { - Self::StdTime(e) + match e { + bdk::Error::Signer(_) => Self::WalletSigningFailed, + _ => Self::WalletOperationFailed, + } } } -impl From for LdkLiteError { - fn from(e: esplora::EsploraError) -> Self { - Self::Esplora(e) +impl From for Error { + fn from(e: lightning_transaction_sync::TxSyncError) -> Self { + match e { + _ => Self::TxSyncFailed, + } } } diff --git a/src/event.rs b/src/event.rs new file mode 100644 index 000000000..4bd62e6e5 --- /dev/null +++ b/src/event.rs @@ -0,0 +1,632 @@ +use crate::{ + hex_utils, ChannelId, ChannelManager, Config, Error, KeysManager, NetworkGraph, PaymentInfo, + PaymentInfoStorage, PaymentStatus, UserChannelId, Wallet, +}; + +use crate::logger::{log_error, log_given_level, log_info, log_internal, Logger}; + +use lightning::chain::chaininterface::{BroadcasterInterface, ConfirmationTarget, FeeEstimator}; +use lightning::ln::PaymentHash; +use lightning::routing::gossip::NodeId; +use lightning::util::errors::APIError; +use lightning::util::events::Event as LdkEvent; +use lightning::util::events::EventHandler as LdkEventHandler; +use lightning::util::events::PaymentPurpose; +use lightning::util::persist::KVStorePersister; +use lightning::util::ser::{Readable, ReadableArgs, Writeable, Writer}; + +use bitcoin::secp256k1::Secp256k1; +use rand::{thread_rng, Rng}; +use std::collections::{hash_map, VecDeque}; +use std::ops::Deref; +use std::sync::{Arc, Condvar, Mutex, RwLock}; +use std::time::Duration; + +/// The event queue will be persisted under this key. +pub(crate) const EVENTS_PERSISTENCE_KEY: &str = "events"; + +/// An event emitted by [`Node`], which should be handled by the user. +/// +/// [`Node`]: [`crate::Node`] +#[derive(Debug, Clone, PartialEq)] +pub enum Event { + /// A sent payment was successful. + PaymentSuccessful { + /// The hash of the payment. + payment_hash: PaymentHash, + }, + /// A sent payment has failed. + PaymentFailed { + /// The hash of the payment. + payment_hash: PaymentHash, + }, + /// A payment has been received. + PaymentReceived { + /// The hash of the payment. + payment_hash: PaymentHash, + /// The value, in thousandths of a satoshi, that has been received. + amount_msat: u64, + }, + /// A channel is ready to be used. + ChannelReady { + /// The `channel_id` of the channel. + channel_id: ChannelId, + /// The `user_channel_id` of the channel. + user_channel_id: UserChannelId, + }, + /// A channel has been closed. + ChannelClosed { + /// The `channel_id` of the channel. + channel_id: ChannelId, + /// The `user_channel_id` of the channel. + user_channel_id: UserChannelId, + }, +} + +// TODO: Figure out serialization more concretely - see issue #30 +impl Readable for Event { + fn read( + reader: &mut R, + ) -> Result { + match Readable::read(reader)? { + 0u8 => { + let payment_hash: PaymentHash = Readable::read(reader)?; + Ok(Self::PaymentSuccessful { payment_hash }) + } + 1u8 => { + let payment_hash: PaymentHash = Readable::read(reader)?; + Ok(Self::PaymentFailed { payment_hash }) + } + 2u8 => { + let payment_hash: PaymentHash = Readable::read(reader)?; + let amount_msat: u64 = Readable::read(reader)?; + Ok(Self::PaymentReceived { payment_hash, amount_msat }) + } + 3u8 => { + let channel_id = ChannelId(Readable::read(reader)?); + let user_channel_id = UserChannelId(Readable::read(reader)?); + Ok(Self::ChannelReady { channel_id, user_channel_id }) + } + 4u8 => { + let channel_id = ChannelId(Readable::read(reader)?); + let user_channel_id = UserChannelId(Readable::read(reader)?); + Ok(Self::ChannelClosed { channel_id, user_channel_id }) + } + _ => Err(lightning::ln::msgs::DecodeError::InvalidValue), + } + } +} + +impl Writeable for Event { + fn write(&self, writer: &mut W) -> Result<(), lightning::io::Error> { + match self { + Self::PaymentSuccessful { payment_hash } => { + 0u8.write(writer)?; + payment_hash.write(writer)?; + Ok(()) + } + Self::PaymentFailed { payment_hash } => { + 1u8.write(writer)?; + payment_hash.write(writer)?; + Ok(()) + } + Self::PaymentReceived { payment_hash, amount_msat } => { + 2u8.write(writer)?; + payment_hash.write(writer)?; + amount_msat.write(writer)?; + Ok(()) + } + Self::ChannelReady { channel_id, user_channel_id } => { + 3u8.write(writer)?; + channel_id.0.write(writer)?; + user_channel_id.0.write(writer)?; + Ok(()) + } + Self::ChannelClosed { channel_id, user_channel_id } => { + 4u8.write(writer)?; + channel_id.0.write(writer)?; + user_channel_id.0.write(writer)?; + Ok(()) + } + } + } +} + +pub(crate) struct EventQueue +where + K::Target: KVStorePersister, +{ + queue: Mutex>, + notifier: Condvar, + persister: K, +} + +impl EventQueue +where + K::Target: KVStorePersister, +{ + pub(crate) fn new(persister: K) -> Self { + let queue: Mutex> = Mutex::new(VecDeque::new()); + let notifier = Condvar::new(); + Self { queue, notifier, persister } + } + + pub(crate) fn add_event(&self, event: Event) -> Result<(), Error> { + { + let mut locked_queue = self.queue.lock().unwrap(); + locked_queue.push_back(event); + self.persist_queue(&*locked_queue)?; + } + + self.notifier.notify_one(); + Ok(()) + } + + pub(crate) fn next_event(&self) -> Event { + let locked_queue = + self.notifier.wait_while(self.queue.lock().unwrap(), |queue| queue.is_empty()).unwrap(); + locked_queue.front().unwrap().clone() + } + + pub(crate) fn event_handled(&self) -> Result<(), Error> { + { + let mut locked_queue = self.queue.lock().unwrap(); + locked_queue.pop_front(); + self.persist_queue(&*locked_queue)?; + } + self.notifier.notify_one(); + Ok(()) + } + + fn persist_queue(&self, locked_queue: &VecDeque) -> Result<(), Error> { + self.persister + .persist(EVENTS_PERSISTENCE_KEY, &EventQueueSerWrapper(locked_queue)) + .map_err(|_| Error::PersistenceFailed)?; + Ok(()) + } +} + +impl ReadableArgs for EventQueue +where + K::Target: KVStorePersister, +{ + #[inline] + fn read( + reader: &mut R, persister: K, + ) -> Result { + let read_queue: EventQueueDeserWrapper = Readable::read(reader)?; + let queue: Mutex> = Mutex::new(read_queue.0); + let notifier = Condvar::new(); + Ok(Self { queue, notifier, persister }) + } +} + +struct EventQueueDeserWrapper(VecDeque); + +impl Readable for EventQueueDeserWrapper { + fn read( + reader: &mut R, + ) -> Result { + let len: u16 = Readable::read(reader)?; + let mut queue = VecDeque::with_capacity(len as usize); + for _ in 0..len { + queue.push_back(Readable::read(reader)?); + } + Ok(Self(queue)) + } +} + +struct EventQueueSerWrapper<'a>(&'a VecDeque); + +impl Writeable for EventQueueSerWrapper<'_> { + fn write(&self, writer: &mut W) -> Result<(), lightning::io::Error> { + (self.0.len() as u16).write(writer)?; + for e in self.0.iter() { + e.write(writer)?; + } + Ok(()) + } +} + +pub(crate) struct EventHandler +where + K::Target: KVStorePersister, + L::Target: Logger, +{ + wallet: Arc>, + event_queue: Arc>, + channel_manager: Arc, + network_graph: Arc, + keys_manager: Arc, + inbound_payments: Arc, + outbound_payments: Arc, + tokio_runtime: RwLock>>, + logger: L, + _config: Arc, +} + +impl EventHandler +where + K::Target: KVStorePersister, + L::Target: Logger, +{ + pub fn new( + wallet: Arc>, event_queue: Arc>, + channel_manager: Arc, network_graph: Arc, + keys_manager: Arc, inbound_payments: Arc, + outbound_payments: Arc, logger: L, _config: Arc, + ) -> Self { + let tokio_runtime = RwLock::new(None); + Self { + event_queue, + wallet, + channel_manager, + network_graph, + keys_manager, + inbound_payments, + outbound_payments, + logger, + tokio_runtime, + _config, + } + } + + pub(crate) fn set_runtime(&self, tokio_runtime: Arc) { + *self.tokio_runtime.write().unwrap() = Some(tokio_runtime); + } + + pub(crate) fn drop_runtime(&self) { + *self.tokio_runtime.write().unwrap() = None; + } +} + +impl LdkEventHandler for EventHandler +where + K::Target: KVStorePersister, + L::Target: Logger, +{ + fn handle_event(&self, event: LdkEvent) { + match event { + LdkEvent::FundingGenerationReady { + temporary_channel_id, + counterparty_node_id, + channel_value_satoshis, + output_script, + .. + } => { + // Construct the raw transaction with the output that is paid the amount of the + // channel. + let confirmation_target = ConfirmationTarget::Normal; + + // Sign the final funding transaction and broadcast it. + match self.wallet.create_funding_transaction( + &output_script, + channel_value_satoshis, + confirmation_target, + ) { + Ok(final_tx) => { + // Give the funding transaction back to LDK for opening the channel. + match self.channel_manager.funding_transaction_generated( + &temporary_channel_id, + &counterparty_node_id, + final_tx, + ) { + Ok(()) => {} + Err(APIError::APIMisuseError { err }) => { + log_error!(self.logger, "Panicking due to APIMisuseError: {}", err); + panic!("APIMisuseError: {}", err); + } + Err(APIError::ChannelUnavailable { err }) => { + log_error!( + self.logger, + "Failed to process funding transaction as channel went away before we could fund it: {}", + err + ) + } + Err(err) => { + log_error!( + self.logger, + "Failed to process funding transaction: {:?}", + err + ) + } + } + } + Err(err) => { + log_error!(self.logger, "Failed to create funding transaction: {}", err); + self.channel_manager + .force_close_without_broadcasting_txn( + &temporary_channel_id, + &counterparty_node_id, + ) + .expect( + "Failed to force close channel after funding generation failed", + ); + } + } + } + LdkEvent::PaymentClaimable { + payment_hash, + purpose, + amount_msat, + receiver_node_id: _, + via_channel_id: _, + via_user_channel_id: _, + } => { + log_info!( + self.logger, + "Received payment from payment hash {} of {} msats", + hex_utils::to_string(&payment_hash.0), + amount_msat, + ); + let payment_preimage = match purpose { + PaymentPurpose::InvoicePayment { payment_preimage, payment_secret } => { + if payment_preimage.is_some() { + payment_preimage + } else { + self.channel_manager + .get_payment_preimage(payment_hash, payment_secret) + .ok() + } + } + PaymentPurpose::SpontaneousPayment(preimage) => Some(preimage), + }; + + if let Some(preimage) = payment_preimage { + self.channel_manager.claim_funds(preimage); + } else { + log_error!( + self.logger, + "Failed to claim payment with hash {}: preimage unknown.", + hex_utils::to_string(&payment_hash.0), + ); + self.channel_manager.fail_htlc_backwards(&payment_hash); + self.inbound_payments.lock().unwrap().remove(&payment_hash); + } + } + LdkEvent::PaymentClaimed { + payment_hash, + purpose, + amount_msat, + receiver_node_id: _, + } => { + log_info!( + self.logger, + "Claimed payment from payment hash {} of {} msats.", + hex_utils::to_string(&payment_hash.0), + amount_msat, + ); + let (payment_preimage, payment_secret) = match purpose { + PaymentPurpose::InvoicePayment { payment_preimage, payment_secret, .. } => { + (payment_preimage, Some(payment_secret)) + } + PaymentPurpose::SpontaneousPayment(preimage) => (Some(preimage), None), + }; + let mut payments = self.inbound_payments.lock().unwrap(); + match payments.entry(payment_hash) { + hash_map::Entry::Occupied(mut e) => { + let payment = e.get_mut(); + payment.status = PaymentStatus::Succeeded; + payment.preimage = payment_preimage; + payment.secret = payment_secret; + } + hash_map::Entry::Vacant(e) => { + e.insert(PaymentInfo { + preimage: payment_preimage, + secret: payment_secret, + status: PaymentStatus::Succeeded, + amount_msat: Some(amount_msat), + }); + } + } + self.event_queue + .add_event(Event::PaymentReceived { payment_hash, amount_msat }) + .expect("Failed to push to event queue"); + } + LdkEvent::PaymentSent { payment_preimage, payment_hash, fee_paid_msat, .. } => { + let mut payments = self.outbound_payments.lock().unwrap(); + for (hash, payment) in payments.iter_mut() { + if *hash == payment_hash { + payment.preimage = Some(payment_preimage); + payment.status = PaymentStatus::Succeeded; + log_info!( + self.logger, + "Successfully sent payment of {} msats{} from \ + payment hash {:?} with preimage {:?}", + payment.amount_msat.unwrap(), + if let Some(fee) = fee_paid_msat { + format!(" (fee {} msats)", fee) + } else { + "".to_string() + }, + hex_utils::to_string(&payment_hash.0), + hex_utils::to_string(&payment_preimage.0) + ); + break; + } + } + self.event_queue + .add_event(Event::PaymentSuccessful { payment_hash }) + .expect("Failed to push to event queue"); + } + LdkEvent::PaymentFailed { payment_hash, .. } => { + log_info!( + self.logger, + "Failed to send payment to payment hash {:?}.", + hex_utils::to_string(&payment_hash.0) + ); + + let mut payments = self.outbound_payments.lock().unwrap(); + if payments.contains_key(&payment_hash) { + let payment = payments.get_mut(&payment_hash).unwrap(); + assert_eq!(payment.status, PaymentStatus::Pending); + payment.status = PaymentStatus::Failed; + } + self.event_queue + .add_event(Event::PaymentFailed { payment_hash }) + .expect("Failed to push to event queue"); + } + + LdkEvent::PaymentPathSuccessful { .. } => {} + LdkEvent::PaymentPathFailed { .. } => {} + LdkEvent::ProbeSuccessful { .. } => {} + LdkEvent::ProbeFailed { .. } => {} + LdkEvent::HTLCHandlingFailed { .. } => {} + LdkEvent::PendingHTLCsForwardable { time_forwardable } => { + let locked_runtime = self.tokio_runtime.read().unwrap(); + if locked_runtime.as_ref().is_none() { + log_error!(self.logger, "Failed process HTLC forwards: No runtime."); + unreachable!("Failed process HTLC forwards: No runtime."); + } + + let forwarding_channel_manager = self.channel_manager.clone(); + let min = time_forwardable.as_millis() as u64; + + locked_runtime.as_ref().unwrap().spawn(async move { + let millis_to_sleep = thread_rng().gen_range(min..min * 5) as u64; + tokio::time::sleep(Duration::from_millis(millis_to_sleep)).await; + + forwarding_channel_manager.process_pending_htlc_forwards(); + }); + } + LdkEvent::SpendableOutputs { outputs } => { + // TODO: We should eventually remember the outputs and supply them to the wallet's coin selection, once BDK allows us to do so. + let destination_address = self.wallet.get_new_address().unwrap(); + let output_descriptors = &outputs.iter().map(|a| a).collect::>(); + let tx_feerate = + self.wallet.get_est_sat_per_1000_weight(ConfirmationTarget::Normal); + let spending_tx = self + .keys_manager + .spend_spendable_outputs( + output_descriptors, + Vec::new(), + destination_address.script_pubkey(), + tx_feerate, + &Secp256k1::new(), + ) + .unwrap(); + self.wallet.broadcast_transaction(&spending_tx); + } + LdkEvent::OpenChannelRequest { .. } => {} + LdkEvent::PaymentForwarded { + prev_channel_id, + next_channel_id, + fee_earned_msat, + claim_from_onchain_tx, + } => { + let read_only_network_graph = self.network_graph.read_only(); + let nodes = read_only_network_graph.nodes(); + let channels = self.channel_manager.list_channels(); + + let node_str = |channel_id: &Option<[u8; 32]>| { + channel_id + .and_then(|channel_id| channels.iter().find(|c| c.channel_id == channel_id)) + .and_then(|channel| { + nodes.get(&NodeId::from_pubkey(&channel.counterparty.node_id)) + }) + .map_or("private_node".to_string(), |node| { + node.announcement_info + .as_ref() + .map_or("unnamed node".to_string(), |ann| { + format!("node {}", ann.alias) + }) + }) + }; + let channel_str = |channel_id: &Option<[u8; 32]>| { + channel_id + .map(|channel_id| { + format!(" with channel {}", hex_utils::to_string(&channel_id)) + }) + .unwrap_or_default() + }; + let from_prev_str = format!( + " from {}{}", + node_str(&prev_channel_id), + channel_str(&prev_channel_id) + ); + let to_next_str = + format!(" to {}{}", node_str(&next_channel_id), channel_str(&next_channel_id)); + + let fee_earned = fee_earned_msat.unwrap_or(0); + if claim_from_onchain_tx { + log_info!( + self.logger, + "Forwarded payment{}{}, earning {} msats in fees from claiming onchain.", + from_prev_str, + to_next_str, + fee_earned, + ); + } else { + log_info!( + self.logger, + "Forwarded payment{}{}, earning {} msats in fees.", + from_prev_str, + to_next_str, + fee_earned, + ); + } + } + LdkEvent::ChannelReady { + channel_id, user_channel_id, counterparty_node_id, .. + } => { + log_info!( + self.logger, + "Channel {} with {} ready to be used.", + hex_utils::to_string(&channel_id), + counterparty_node_id, + ); + self.event_queue + .add_event(Event::ChannelReady { + channel_id: ChannelId(channel_id), + user_channel_id: UserChannelId(user_channel_id), + }) + .expect("Failed to push to event queue"); + } + LdkEvent::ChannelClosed { channel_id, reason, user_channel_id } => { + log_info!( + self.logger, + "Channel {} closed due to: {:?}", + hex_utils::to_string(&channel_id), + reason + ); + self.event_queue + .add_event(Event::ChannelClosed { + channel_id: ChannelId(channel_id), + user_channel_id: UserChannelId(user_channel_id), + }) + .expect("Failed to push to event queue"); + } + LdkEvent::DiscardFunding { .. } => {} + LdkEvent::HTLCIntercepted { .. } => {} + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::tests::test_utils::TestPersister; + + #[test] + fn event_queue_persistence() { + let test_persister = Arc::new(TestPersister::new()); + let event_queue = EventQueue::new(Arc::clone(&test_persister)); + + let expected_event = Event::ChannelReady { + channel_id: ChannelId([23u8; 32]), + user_channel_id: UserChannelId(2323), + }; + event_queue.add_event(expected_event.clone()).unwrap(); + assert!(test_persister.get_and_clear_pending_persist()); + + // Check we get the expected event and that it is returned until we mark it handled. + for _ in 0..5 { + assert_eq!(event_queue.next_event(), expected_event); + assert_eq!(false, test_persister.get_and_clear_pending_persist()); + } + + // Check we persisted on `event_handled()` + event_queue.event_handled().unwrap(); + assert!(test_persister.get_and_clear_pending_persist()); + } +} diff --git a/src/io_utils.rs b/src/io_utils.rs new file mode 100644 index 000000000..a295e100c --- /dev/null +++ b/src/io_utils.rs @@ -0,0 +1,66 @@ +use crate::{Config, Error, FilesystemLogger, NetworkGraph, Scorer}; + +use lightning::routing::scoring::{ProbabilisticScorer, ProbabilisticScoringParameters}; +use lightning::util::ser::ReadableArgs; + +use rand::{thread_rng, RngCore}; + +use std::fs; +use std::io::{BufReader, Write}; +use std::path::Path; +use std::sync::Arc; + +pub(crate) fn read_or_generate_seed_file(config: Arc) -> [u8; 32] { + let keys_seed_path = format!("{}/keys_seed", config.storage_dir_path); + let keys_seed = if Path::new(&keys_seed_path).exists() { + let seed = fs::read(keys_seed_path.clone()).expect("Failed to read keys seed file"); + assert_eq!(seed.len(), 32); + let mut key = [0; 32]; + key.copy_from_slice(&seed); + key + } else { + let mut key = [0; 32]; + thread_rng().fill_bytes(&mut key); + + let mut f = + fs::File::create(keys_seed_path.clone()).expect("Failed to create keys seed file"); + f.write_all(&key).expect("Failed to write node keys seed to disk"); + f.sync_all().expect("Failed to sync node keys seed to disk"); + key + }; + + keys_seed +} + +pub(crate) fn read_network_graph( + config: Arc, logger: Arc, +) -> Result { + let ldk_data_dir = format!("{}/ldk", &config.storage_dir_path.clone()); + let network_graph_path = format!("{}/network_graph", ldk_data_dir.clone()); + + if let Ok(file) = fs::File::open(network_graph_path) { + if let Ok(graph) = NetworkGraph::read(&mut BufReader::new(file), Arc::clone(&logger)) { + return Ok(graph); + } + } + + let genesis_hash = + bitcoin::blockdata::constants::genesis_block(config.network).header.block_hash(); + Ok(NetworkGraph::new(genesis_hash, logger)) +} + +pub(crate) fn read_scorer( + config: Arc, network_graph: Arc, logger: Arc, +) -> Scorer { + let ldk_data_dir = format!("{}/ldk", &config.storage_dir_path.clone()); + let scorer_path = format!("{}/scorer", ldk_data_dir.clone()); + + let params = ProbabilisticScoringParameters::default(); + if let Ok(file) = fs::File::open(scorer_path) { + let args = (params.clone(), Arc::clone(&network_graph), Arc::clone(&logger)); + if let Ok(scorer) = ProbabilisticScorer::read(&mut BufReader::new(file), args) { + return scorer; + } + } + ProbabilisticScorer::new(params, network_graph, logger) +} diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 000000000..950c3524d --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,1208 @@ +// This file is Copyright its original authors, visible in version contror +// history. +// +// This file is licensed under the Apache License, Version 2.0 or the MIT license +// , at your option. +// You may not use this file except in accordance with one or both of these +// licenses. + +#![crate_name = "ldk_node"] + +//! A library providing a simplified API for the Lightning Dev Kit. While LDK itself provides a +//! highly configurable and adaptable interface, this API champions simplicity and ease of use over +//! configurability. To this end, it provides an opionated set of design choices and ready-to-go +//! default modules, while still enabling some configurability when dearly needed by the user: +//! - Chain data is accessed through an Esplora client. +//! - Wallet and channel states are persisted to disk. +//! - Gossip is retrieved over the P2P network. + +#![deny(broken_intra_doc_links)] +#![deny(private_intra_doc_links)] +#![allow(bare_trait_objects)] +#![allow(ellipsis_inclusive_range_patterns)] +#![cfg_attr(docsrs, feature(doc_auto_cfg))] + +mod error; +mod event; +mod hex_utils; +mod io_utils; +mod logger; +mod peer_store; +#[cfg(test)] +mod tests; +mod wallet; + +pub use error::Error as NodeError; +use error::Error; +pub use event::Event; +use event::{EventHandler, EventQueue}; +use peer_store::{PeerInfo, PeerInfoStorage}; +use wallet::{Wallet, WalletKeysManager}; + +use logger::{log_error, log_given_level, log_info, log_internal, FilesystemLogger, Logger}; + +use lightning::chain::keysinterface::{EntropySource, InMemorySigner, NodeSigner, Recipient}; +use lightning::chain::{chainmonitor, Access, BestBlock, Confirm, Watch}; +use lightning::ln::channelmanager; +use lightning::ln::channelmanager::{ChainParameters, ChannelManagerReadArgs}; +use lightning::ln::peer_handler::{IgnoringMessageHandler, MessageHandler}; +use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret}; +use lightning::routing::gossip; +use lightning::routing::gossip::P2PGossipSync; +use lightning::routing::scoring::ProbabilisticScorer; + +use lightning::util::config::{ChannelHandshakeConfig, ChannelHandshakeLimits, UserConfig}; +use lightning::util::ser::ReadableArgs; + +use lightning_background_processor::BackgroundProcessor; +use lightning_background_processor::GossipSync as BPGossipSync; +use lightning_persister::FilesystemPersister; + +use lightning_transaction_sync::EsploraSyncClient; + +use lightning_net_tokio::SocketDescriptor; + +use lightning::routing::router::DefaultRouter; +use lightning_invoice::{payment, Currency, Invoice, SignedRawInvoice}; + +use bdk::bitcoin::secp256k1::Secp256k1; +use bdk::blockchain::esplora::EsploraBlockchain; +use bdk::sled; +use bdk::template::Bip84; + +use bitcoin::hashes::sha256::Hash as Sha256; +use bitcoin::hashes::Hash; +use bitcoin::secp256k1::PublicKey; +use bitcoin::{Address, BlockHash}; + +use rand::Rng; + +use core::str::FromStr; +use std::collections::HashMap; +use std::convert::{TryFrom, TryInto}; +use std::default::Default; +use std::fs; +use std::net::SocketAddr; +use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::{Arc, Mutex, RwLock}; +use std::time::{Duration, Instant, SystemTime}; + +uniffi_macros::include_scaffolding!("ldk_node"); + +// The used 'stop gap' parameter used by BDK's wallet sync. This seems to configure the threshold +// number of blocks after which BDK stops looking for scripts belonging to the wallet. +const BDK_CLIENT_STOP_GAP: usize = 20; + +// The number of concurrent requests made against the API provider. +const BDK_CLIENT_CONCURRENCY: u8 = 8; + +// The timeout after which we abandon retrying failed payments. +const LDK_PAYMENT_RETRY_TIMEOUT: Duration = Duration::from_secs(10); + +#[derive(Debug, Clone)] +/// Represents the configuration of an [`Node`] instance. +pub struct Config { + /// The path where the underlying LDK and BDK persist their data. + pub storage_dir_path: String, + /// The URL of the utilized Esplora server. + pub esplora_server_url: String, + /// The used Bitcoin network. + pub network: bitcoin::Network, + /// The IP address and TCP port the node will listen on. + pub listening_address: Option, + /// The default CLTV expiry delta to be used for payments. + pub default_cltv_expiry_delta: u32, +} + +impl Default for Config { + fn default() -> Self { + // Set the config defaults + let storage_dir_path = "/tmp/ldk_node/".to_string(); + let esplora_server_url = "https://blockstream.info/api".to_string(); + let network = bitcoin::Network::Regtest; + let listening_address = Some("0.0.0.0:9735".to_string()); + let default_cltv_expiry_delta = 144; + + Self { + storage_dir_path, + esplora_server_url, + network, + listening_address, + default_cltv_expiry_delta, + } + } +} + +/// A builder for an [`Node`] instance, allowing to set some configuration and module choices from +/// the getgo. +#[derive(Debug, Clone)] +pub struct Builder { + config: Config, +} + +impl Builder { + /// Creates a new builder instance with the default configuration. + pub fn new() -> Self { + let config = Config::default(); + + Self { config } + } + + /// Creates a new builder instance from an [`Config`]. + pub fn from_config(config: Config) -> Self { + Self { config } + } + + /// Sets the used storage directory path. + /// + /// Default: `/tmp/ldk_node/` + pub fn set_storage_dir_path(&mut self, storage_dir_path: String) -> &mut Self { + self.config.storage_dir_path = storage_dir_path; + self + } + + /// Sets the Esplora server URL. + /// + /// Default: `https://blockstream.info/api` + pub fn set_esplora_server_url(&mut self, esplora_server_url: String) -> &mut Self { + self.config.esplora_server_url = esplora_server_url; + self + } + + /// Sets the Bitcoin network used. + /// + /// Options: `mainnet`/`bitcoin`, `testnet`, `regtest`, `signet` + /// + /// Default: `testnet` + pub fn set_network(&mut self, network: &str) -> &mut Self { + self.config.network = match network { + "mainnet" => bitcoin::Network::Bitcoin, + "bitcoin" => bitcoin::Network::Bitcoin, + "testnet" => bitcoin::Network::Testnet, + "regtest" => bitcoin::Network::Regtest, + "signet" => bitcoin::Network::Signet, + _ => bitcoin::Network::Regtest, + }; + self + } + + /// Sets the IP address and TCP port on which [`Node`] will listen for incoming network connections. + /// + /// Format: `ADDR:PORT` + /// Default: `0.0.0.0:9735` + pub fn set_listening_address(&mut self, listening_address: String) -> &mut Self { + self.config.listening_address = Some(listening_address); + self + } + + /// Builds a [`Node`] instance according to the options previously configured. + pub fn build(&self) -> Arc { + let config = Arc::new(self.config.clone()); + + let ldk_data_dir = format!("{}/ldk", &config.storage_dir_path.clone()); + fs::create_dir_all(ldk_data_dir.clone()).expect("Failed to create LDK data directory"); + + let bdk_data_dir = format!("{}/bdk", config.storage_dir_path.clone()); + fs::create_dir_all(bdk_data_dir.clone()).expect("Failed to create BDK data directory"); + + // Step 0: Initialize the Logger + let log_file_path = format!("{}/ldk_node.log", config.storage_dir_path.clone()); + let logger = Arc::new(FilesystemLogger::new(log_file_path)); + + // Step 1: Initialize the on-chain wallet and chain access + let seed = io_utils::read_or_generate_seed_file(Arc::clone(&config)); + let xprv = bitcoin::util::bip32::ExtendedPrivKey::new_master(config.network, &seed) + .expect("Failed to read wallet master key"); + + let wallet_name = bdk::wallet::wallet_name_from_descriptor( + Bip84(xprv.clone(), bdk::KeychainKind::External), + Some(Bip84(xprv.clone(), bdk::KeychainKind::Internal)), + config.network, + &Secp256k1::new(), + ) + .expect("Failed to derive on-chain wallet name"); + let database = sled::open(bdk_data_dir).expect("Failed to open BDK database"); + let database = + database.open_tree(wallet_name.clone()).expect("Failed to open BDK database"); + + let bdk_wallet = bdk::Wallet::new( + Bip84(xprv.clone(), bdk::KeychainKind::External), + Some(Bip84(xprv.clone(), bdk::KeychainKind::Internal)), + config.network, + database, + ) + .expect("Failed to setup on-chain wallet"); + + // TODO: Check that we can be sure that the Esplora client re-connects in case of failure + // and and exits cleanly on drop. Otherwise we need to handle this/move it to the runtime? + let blockchain = EsploraBlockchain::new(&config.esplora_server_url, BDK_CLIENT_STOP_GAP) + .with_concurrency(BDK_CLIENT_CONCURRENCY); + + let wallet = Arc::new(Wallet::new(blockchain, bdk_wallet, Arc::clone(&logger))); + + let tx_sync = Arc::new(EsploraSyncClient::new( + config.esplora_server_url.clone(), + Arc::clone(&logger), + )); + + // Step 3: Initialize Persist + let persister = Arc::new(FilesystemPersister::new(ldk_data_dir.clone())); + + // Step 4: Initialize the ChainMonitor + let chain_monitor: Arc = Arc::new(chainmonitor::ChainMonitor::new( + Some(Arc::clone(&tx_sync)), + Arc::clone(&wallet), + Arc::clone(&logger), + Arc::clone(&wallet), + Arc::clone(&persister), + )); + + // Step 5: Initialize the KeysManager + let cur_time = SystemTime::now() + .duration_since(SystemTime::UNIX_EPOCH) + .expect("System time error: Clock may have gone backwards"); + let keys_manager = Arc::new(KeysManager::new( + &seed, + cur_time.as_secs(), + cur_time.subsec_nanos(), + Arc::clone(&wallet), + )); + + // Step 6: Read ChannelMonitor state from disk + let mut channel_monitors = persister + .read_channelmonitors(keys_manager.clone()) + .expect("Failed to read channel monitors from disk"); + + // Step 7: Initialize the ChannelManager + let mut user_config = UserConfig::default(); + user_config.channel_handshake_limits.force_announced_channel_preference = false; + let channel_manager = { + if let Ok(mut f) = fs::File::open(format!("{}/manager", ldk_data_dir.clone())) { + let mut channel_monitor_mut_references = Vec::new(); + for (_, channel_monitor) in channel_monitors.iter_mut() { + channel_monitor_mut_references.push(channel_monitor); + } + let read_args = ChannelManagerReadArgs::new( + Arc::clone(&keys_manager), + Arc::clone(&wallet), + Arc::clone(&chain_monitor), + Arc::clone(&wallet), + Arc::clone(&logger), + user_config, + channel_monitor_mut_references, + ); + let (_hash, channel_manager) = + <(BlockHash, ChannelManager)>::read(&mut f, read_args) + .expect("Failed to read channel manager from disk"); + channel_manager + } else { + // We're starting a fresh node. + let dummy_block_hash = bitcoin::blockdata::constants::genesis_block(config.network) + .header + .block_hash(); + + let chain_params = ChainParameters { + network: config.network, + best_block: BestBlock::new(dummy_block_hash, 0), + }; + let fresh_channel_manager = channelmanager::ChannelManager::new( + Arc::clone(&wallet), + Arc::clone(&chain_monitor), + Arc::clone(&wallet), + Arc::clone(&logger), + Arc::clone(&keys_manager), + user_config, + chain_params, + ); + fresh_channel_manager + } + }; + + let channel_manager = Arc::new(channel_manager); + + // Step 8: Give ChannelMonitors to ChainMonitor + for (_blockhash, channel_monitor) in channel_monitors.drain(..) { + let funding_outpoint = channel_monitor.get_funding_txo().0; + chain_monitor.watch_channel(funding_outpoint, channel_monitor); + } + + // Step 10: Initialize the P2PGossipSync + let network_graph = Arc::new( + io_utils::read_network_graph(Arc::clone(&config), Arc::clone(&logger)) + .expect("Failed to read the network graph"), + ); + let gossip_sync = Arc::new(P2PGossipSync::new( + Arc::clone(&network_graph), + None::>, + Arc::clone(&logger), + )); + + //// Step 11: Initialize the PeerManager + let onion_messenger: Arc = Arc::new(OnionMessenger::new( + Arc::clone(&keys_manager), + Arc::clone(&logger), + IgnoringMessageHandler {}, + )); + let ephemeral_bytes: [u8; 32] = rand::thread_rng().gen(); + let lightning_msg_handler = MessageHandler { + chan_handler: Arc::clone(&channel_manager), + route_handler: Arc::clone(&gossip_sync), + onion_message_handler: onion_messenger, + }; + + let cur_time = SystemTime::now() + .duration_since(SystemTime::UNIX_EPOCH) + .expect("System time error: Clock may have gone backwards"); + let peer_manager: Arc = Arc::new(PeerManager::new( + lightning_msg_handler, + keys_manager.get_node_secret(Recipient::Node).unwrap(), + cur_time.as_secs().try_into().expect("System time error"), + &ephemeral_bytes, + Arc::clone(&logger), + IgnoringMessageHandler {}, + )); + + // Step 12: Initialize routing ProbabilisticScorer + let scorer = Arc::new(Mutex::new(io_utils::read_scorer( + Arc::clone(&config), + Arc::clone(&network_graph), + Arc::clone(&logger), + ))); + + // Step 13: Init payment info storage + // TODO: persist payment info to disk + let inbound_payments = Arc::new(Mutex::new(HashMap::new())); + let outbound_payments = Arc::new(Mutex::new(HashMap::new())); + + // Step 14: Restore event handler from disk or create a new one. + let event_queue = if let Ok(mut f) = + fs::File::open(format!("{}/{}", ldk_data_dir.clone(), event::EVENTS_PERSISTENCE_KEY)) + { + Arc::new( + EventQueue::read(&mut f, Arc::clone(&persister)) + .expect("Failed to read event queue from disk."), + ) + } else { + Arc::new(EventQueue::new(Arc::clone(&persister))) + }; + + let event_handler = Arc::new(EventHandler::new( + Arc::clone(&wallet), + Arc::clone(&event_queue), + Arc::clone(&channel_manager), + Arc::clone(&network_graph), + Arc::clone(&keys_manager), + Arc::clone(&inbound_payments), + Arc::clone(&outbound_payments), + Arc::clone(&logger), + Arc::clone(&config), + )); + + //// Step 16: Create Router and InvoicePayer + let router = DefaultRouter::new( + Arc::clone(&network_graph), + Arc::clone(&logger), + keys_manager.get_secure_random_bytes(), + Arc::clone(&scorer), + ); + + let invoice_payer = Arc::new(InvoicePayer::new( + Arc::clone(&channel_manager), + router, + Arc::clone(&logger), + Arc::clone(&event_handler), + payment::Retry::Timeout(LDK_PAYMENT_RETRY_TIMEOUT), + )); + + let peer_store = if let Ok(mut f) = fs::File::open(format!( + "{}/{}", + ldk_data_dir.clone(), + peer_store::PEER_INFO_PERSISTENCE_KEY + )) { + Arc::new( + PeerInfoStorage::read(&mut f, Arc::clone(&persister)) + .expect("Failed to read peer information from disk."), + ) + } else { + Arc::new(PeerInfoStorage::new(Arc::clone(&persister))) + }; + + let running = RwLock::new(None); + + Arc::new(Node { + running, + config, + wallet, + tx_sync, + event_queue, + event_handler, + channel_manager, + chain_monitor, + peer_manager, + keys_manager, + gossip_sync, + persister, + logger, + scorer, + invoice_payer, + inbound_payments, + outbound_payments, + peer_store, + }) + } +} + +/// Wraps all objects that need to be preserved during the run time of [`Node`]. Will be dropped +/// upon [`Node::stop()`]. +struct Runtime { + tokio_runtime: Arc, + _background_processor: BackgroundProcessor, + stop_networking: Arc, + stop_wallet_sync: Arc, +} + +/// The main interface object of the simplified API, wrapping the necessary LDK and BDK functionalities. +/// +/// Needs to be initialized and instantiated through [`Builder::build`]. +pub struct Node { + running: RwLock>, + config: Arc, + wallet: Arc>, + tx_sync: Arc>>, + event_queue: Arc>>, + event_handler: Arc, Arc>>, + channel_manager: Arc, + chain_monitor: Arc, + peer_manager: Arc, + keys_manager: Arc, + gossip_sync: Arc, + persister: Arc, + logger: Arc, + scorer: Arc>, + invoice_payer: + Arc, Arc>>>>, + inbound_payments: Arc, + outbound_payments: Arc, + peer_store: Arc>, +} + +impl Node { + /// Starts the necessary background tasks, such as handling events coming from user input, + /// LDK/BDK, and the peer-to-peer network. After this returns, the [`Node`] instance can be + /// controlled via the provided API methods in a thread-safe manner. + pub fn start(&self) -> Result<(), Error> { + // Acquire a run lock and hold it until we're setup. + let mut run_lock = self.running.write().unwrap(); + if run_lock.is_some() { + // We're already running. + return Err(Error::AlreadyRunning); + } + + let runtime = self.setup_runtime()?; + *run_lock = Some(runtime); + Ok(()) + } + + /// Disconnects all peers, stops all running background tasks, and shuts down [`Node`]. + pub fn stop(&self) -> Result<(), Error> { + let mut run_lock = self.running.write().unwrap(); + if run_lock.is_none() { + return Err(Error::NotRunning); + } + + let runtime = run_lock.as_ref().unwrap(); + + // Stop wallet sync + runtime.stop_wallet_sync.store(true, Ordering::Release); + + // Stop networking + runtime.stop_networking.store(true, Ordering::Release); + self.peer_manager.disconnect_all_peers(); + + // Drop the held runtimes. + self.wallet.drop_runtime(); + self.event_handler.drop_runtime(); + + // Drop the runtime, which stops the background processor and any possibly remaining tokio threads. + *run_lock = None; + Ok(()) + } + + fn setup_runtime(&self) -> Result { + let tokio_runtime = + Arc::new(tokio::runtime::Builder::new_multi_thread().enable_all().build().unwrap()); + + self.wallet.set_runtime(Arc::clone(&tokio_runtime)); + self.event_handler.set_runtime(Arc::clone(&tokio_runtime)); + + // Setup wallet sync + let wallet = Arc::clone(&self.wallet); + let tx_sync = Arc::clone(&self.tx_sync); + let sync_cman = Arc::clone(&self.channel_manager); + let sync_cmon = Arc::clone(&self.chain_monitor); + let sync_logger = Arc::clone(&self.logger); + let stop_wallet_sync = Arc::new(AtomicBool::new(false)); + let stop_sync = Arc::clone(&stop_wallet_sync); + + std::thread::spawn(move || { + tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap().block_on( + async move { + loop { + if stop_sync.load(Ordering::Acquire) { + return; + } + let now = Instant::now(); + match wallet.sync().await { + Ok(()) => log_info!( + sync_logger, + "On-chain wallet sync finished in {}ms.", + now.elapsed().as_millis() + ), + Err(err) => { + log_error!(sync_logger, "On-chain wallet sync failed: {}", err) + } + } + tokio::time::sleep(Duration::from_secs(20)).await; + } + }, + ); + }); + + let sync_logger = Arc::clone(&self.logger); + let stop_sync = Arc::clone(&stop_wallet_sync); + tokio_runtime.spawn(async move { + loop { + if stop_sync.load(Ordering::Acquire) { + return; + } + let now = Instant::now(); + let confirmables = vec![ + &*sync_cman as &(dyn Confirm + Sync + Send), + &*sync_cmon as &(dyn Confirm + Sync + Send), + ]; + match tx_sync.sync(confirmables).await { + Ok(()) => log_info!( + sync_logger, + "Lightning wallet sync finished in {}ms.", + now.elapsed().as_millis() + ), + Err(e) => { + log_error!(sync_logger, "Lightning wallet sync failed: {}", e) + } + } + tokio::time::sleep(Duration::from_secs(5)).await; + } + }); + + let stop_networking = Arc::new(AtomicBool::new(false)); + if let Some(listening_address) = &self.config.listening_address { + // Setup networking + let peer_manager_connection_handler = Arc::clone(&self.peer_manager); + let stop_listen = Arc::clone(&stop_networking); + let listening_address = listening_address.clone(); + + tokio_runtime.spawn(async move { + let listener = + tokio::net::TcpListener::bind(listening_address).await.expect( + "Failed to bind to listen address/port - is something else already listening on it?", + ); + loop { + if stop_listen.load(Ordering::Acquire) { + return; + } + let peer_mgr = Arc::clone(&peer_manager_connection_handler); + let tcp_stream = listener.accept().await.unwrap().0; + tokio::spawn(async move { + lightning_net_tokio::setup_inbound( + Arc::clone(&peer_mgr), + tcp_stream.into_std().unwrap(), + ) + .await; + }); + } + }); + } + + // Regularly reconnect to channel peers. + let connect_cm = Arc::clone(&self.channel_manager); + let connect_pm = Arc::clone(&self.peer_manager); + let connect_logger = Arc::clone(&self.logger); + let connect_peer_store = Arc::clone(&self.peer_store); + let stop_connect = Arc::clone(&stop_networking); + tokio_runtime.spawn(async move { + let mut interval = tokio::time::interval(Duration::from_secs(1)); + loop { + if stop_connect.load(Ordering::Acquire) { + return; + } + interval.tick().await; + let pm_peers = connect_pm.get_peer_node_ids(); + for node_id in connect_cm + .list_channels() + .iter() + .map(|chan| chan.counterparty.node_id) + .filter(|id| !pm_peers.contains(id)) + { + for peer_info in connect_peer_store.peers() { + if peer_info.pubkey == node_id { + let _ = do_connect_peer( + peer_info.pubkey, + peer_info.address.clone(), + Arc::clone(&connect_pm), + Arc::clone(&connect_logger), + ) + .await; + } + } + } + } + }); + + // Setup background processing + let _background_processor = BackgroundProcessor::start( + Arc::clone(&self.persister), + Arc::clone(&self.invoice_payer), + Arc::clone(&self.chain_monitor), + Arc::clone(&self.channel_manager), + BPGossipSync::p2p(Arc::clone(&self.gossip_sync)), + Arc::clone(&self.peer_manager), + Arc::clone(&self.logger), + Some(Arc::clone(&self.scorer)), + ); + + // TODO: frequently check back on background_processor if there was an error + + Ok(Runtime { tokio_runtime, _background_processor, stop_networking, stop_wallet_sync }) + } + + /// Blocks until the next event is available. + /// + /// Note: this will always return the same event until handling is confirmed via [`Node::event_handled`]. + pub fn next_event(&self) -> Event { + self.event_queue.next_event() + } + + /// Confirm the last retrieved event handled. + pub fn event_handled(&self) { + self.event_queue.event_handled().unwrap(); + } + + /// Returns our own node id + pub fn node_id(&self) -> Result { + Ok(self.channel_manager.get_our_node_id()) + } + + /// Returns our own listening address and port. + pub fn listening_address(&self) -> Option { + self.config.listening_address.clone() + } + + /// Retrieve a new on-chain/funding address. + pub fn new_funding_address(&self) -> Result { + let funding_address = self.wallet.get_new_address()?; + log_info!(self.logger, "Generated new funding address: {}", funding_address); + Ok(funding_address) + } + + #[cfg(test)] + /// Retrieve the current on-chain balance. + pub fn on_chain_balance(&self) -> Result { + self.wallet.get_balance() + } + + /// Connect to a node and open a new channel. Disconnects and re-connects are handled automatically + /// + /// Returns a temporary channel id + pub fn connect_open_channel( + &self, node_pubkey_and_address: &str, channel_amount_sats: u64, announce_channel: bool, + ) -> Result<(), Error> { + let runtime_lock = self.running.read().unwrap(); + if runtime_lock.is_none() { + return Err(Error::NotRunning); + } + + let peer_info = PeerInfo::try_from(node_pubkey_and_address.to_string())?; + + let runtime = runtime_lock.as_ref().unwrap(); + + let con_peer_info = peer_info.clone(); + let con_success = Arc::new(AtomicBool::new(false)); + let con_success_cloned = Arc::clone(&con_success); + let con_logger = Arc::clone(&self.logger); + let con_pm = Arc::clone(&self.peer_manager); + + tokio::task::block_in_place(move || { + runtime.tokio_runtime.block_on(async move { + let res = connect_peer_if_necessary( + con_peer_info.pubkey, + con_peer_info.address, + con_pm, + con_logger, + ) + .await; + con_success_cloned.store(res.is_ok(), Ordering::Release); + }) + }); + + if !con_success.load(Ordering::Acquire) { + return Err(Error::ConnectionFailed); + } + + let user_config = UserConfig { + channel_handshake_limits: ChannelHandshakeLimits { + // lnd's max to_self_delay is 2016, so we want to be compatible. + their_to_self_delay: 2016, + ..Default::default() + }, + channel_handshake_config: ChannelHandshakeConfig { + announced_channel: announce_channel, + ..Default::default() + }, + ..Default::default() + }; + + let user_channel_id: u128 = rand::thread_rng().gen::(); + + match self.channel_manager.create_channel( + peer_info.pubkey, + channel_amount_sats, + 0, + user_channel_id, + Some(user_config), + ) { + Ok(_) => { + self.peer_store.add_peer(peer_info.clone())?; + log_info!( + self.logger, + "Initiated channel creation with peer {}. ", + peer_info.pubkey + ); + Ok(()) + } + Err(e) => { + log_error!(self.logger, "Failed to initiate channel creation: {:?}", e); + Err(Error::ChannelCreationFailed) + } + } + } + + #[cfg(test)] + pub fn sync_wallets(&self) -> Result<(), Error> { + let runtime_lock = self.running.read().unwrap(); + if runtime_lock.is_none() { + return Err(Error::NotRunning); + } + let wallet = Arc::clone(&self.wallet); + let tx_sync = Arc::clone(&self.tx_sync); + let sync_cman = Arc::clone(&self.channel_manager); + let sync_cmon = Arc::clone(&self.chain_monitor); + let confirmables = vec![ + &*sync_cman as &(dyn Confirm + Sync + Send), + &*sync_cmon as &(dyn Confirm + Sync + Send), + ]; + + let runtime = runtime_lock.as_ref().unwrap(); + tokio::task::block_in_place(move || { + runtime.tokio_runtime.block_on(async move { wallet.sync().await }) + })?; + + tokio::task::block_in_place(move || { + runtime.tokio_runtime.block_on(async move { tx_sync.sync(confirmables).await }) + })?; + + Ok(()) + } + + /// Close a previously opened channel. + pub fn close_channel( + &self, channel_id: &[u8; 32], counterparty_node_id: &PublicKey, + ) -> Result<(), Error> { + self.peer_store.remove_peer(counterparty_node_id)?; + match self.channel_manager.close_channel(channel_id, counterparty_node_id) { + Ok(_) => Ok(()), + Err(_) => Err(Error::ChannelClosingFailed), + } + } + + /// Send a payement given an invoice. + pub fn send_payment(&self, invoice: Invoice) -> Result { + if self.running.read().unwrap().is_none() { + return Err(Error::NotRunning); + } + + // TODO: ensure we never tried paying the given payment hash before + let status = match self.invoice_payer.pay_invoice(&invoice) { + Ok(_payment_id) => { + let payee_pubkey = invoice.recover_payee_pub_key(); + // TODO: is this unwrap safe? Would a payment to an invoice with None amount ever + // succeed? Should we allow to set the amount in the interface or via a dedicated + // method? + let amt_msat = invoice.amount_milli_satoshis().unwrap(); + log_info!(self.logger, "Initiated sending {} msats to {}", amt_msat, payee_pubkey); + PaymentStatus::Pending + } + Err(payment::PaymentError::Invoice(e)) => { + log_error!(self.logger, "Failed to send payment due to invalid invoice: {}", e); + return Err(Error::InvoiceInvalid); + } + Err(payment::PaymentError::Routing(e)) => { + log_error!(self.logger, "Failed to send payment due to routing failure: {}", e.err); + return Err(Error::RoutingFailed); + } + Err(payment::PaymentError::Sending(e)) => { + log_error!(self.logger, "Failed to send payment: {:?}", e); + PaymentStatus::Failed + } + }; + + let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner()); + let payment_secret = Some(invoice.payment_secret().clone()); + + let mut outbound_payments_lock = self.outbound_payments.lock().unwrap(); + outbound_payments_lock.insert( + payment_hash, + PaymentInfo { + preimage: None, + secret: payment_secret, + status, + amount_msat: invoice.amount_milli_satoshis(), + }, + ); + + Ok(payment_hash) + } + + /// Send a spontaneous, aka. "keysend", payment + pub fn send_spontaneous_payment( + &self, amount_msat: u64, node_id: &str, + ) -> Result { + if self.running.read().unwrap().is_none() { + return Err(Error::NotRunning); + } + + let pubkey = hex_utils::to_compressed_pubkey(node_id).ok_or(Error::PeerInfoParseFailed)?; + + let payment_preimage = PaymentPreimage(self.keys_manager.get_secure_random_bytes()); + let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0).into_inner()); + + let status = match self.invoice_payer.pay_pubkey( + pubkey, + payment_preimage, + amount_msat, + self.config.default_cltv_expiry_delta, + ) { + Ok(_payment_id) => { + log_info!(self.logger, "Initiated sending {} msats to {}.", amount_msat, node_id); + PaymentStatus::Pending + } + Err(payment::PaymentError::Invoice(e)) => { + log_error!(self.logger, "Failed to send payment due to invalid invoice: {}", e); + return Err(Error::InvoiceInvalid); + } + Err(payment::PaymentError::Routing(e)) => { + log_error!(self.logger, "Failed to send payment due to routing failure: {}", e.err); + return Err(Error::RoutingFailed); + } + Err(payment::PaymentError::Sending(e)) => { + log_error!(self.logger, "Failed to send payment: {:?}", e); + PaymentStatus::Failed + } + }; + + let mut outbound_payments_lock = self.outbound_payments.lock().unwrap(); + outbound_payments_lock.insert( + payment_hash, + PaymentInfo { preimage: None, secret: None, status, amount_msat: Some(amount_msat) }, + ); + + Ok(payment_hash) + } + + /// Returns a payable invoice that can be used to request and receive a payment. + pub fn receive_payment( + &self, amount_msat: Option, description: &str, expiry_secs: u32, + ) -> Result { + let mut inbound_payments_lock = self.inbound_payments.lock().unwrap(); + + let currency = match self.config.network { + bitcoin::Network::Bitcoin => Currency::Bitcoin, + bitcoin::Network::Testnet => Currency::BitcoinTestnet, + bitcoin::Network::Regtest => Currency::Regtest, + bitcoin::Network::Signet => Currency::Signet, + }; + let keys_manager = Arc::clone(&self.keys_manager); + let invoice = match lightning_invoice::utils::create_invoice_from_channelmanager( + &self.channel_manager, + keys_manager, + Arc::clone(&self.logger), + currency, + amount_msat, + description.to_string(), + expiry_secs, + ) { + Ok(inv) => { + log_info!(self.logger, "Invoice created: {}", inv); + inv + } + Err(e) => { + log_error!(self.logger, "Failed to create invoice: {}", e); + return Err(Error::InvoiceCreationFailed); + } + }; + + let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner()); + inbound_payments_lock.insert( + payment_hash, + PaymentInfo { + preimage: None, + secret: Some(invoice.payment_secret().clone()), + status: PaymentStatus::Pending, + amount_msat, + }, + ); + Ok(invoice) + } + + /// Query for information about the status of a specific payment. + pub fn payment_info(&self, payment_hash: &[u8; 32]) -> Option { + let payment_hash = PaymentHash(*payment_hash); + + { + let outbound_payments_lock = self.outbound_payments.lock().unwrap(); + if let Some(payment_info) = outbound_payments_lock.get(&payment_hash) { + return Some((*payment_info).clone()); + } + } + + { + let inbound_payments_lock = self.inbound_payments.lock().unwrap(); + if let Some(payment_info) = inbound_payments_lock.get(&payment_hash) { + return Some((*payment_info).clone()); + } + } + + None + } +} + +async fn connect_peer_if_necessary( + pubkey: PublicKey, peer_addr: SocketAddr, peer_manager: Arc, + logger: Arc, +) -> Result<(), Error> { + for node_pubkey in peer_manager.get_peer_node_ids() { + if node_pubkey == pubkey { + return Ok(()); + } + } + + do_connect_peer(pubkey, peer_addr, peer_manager, logger).await +} + +async fn do_connect_peer( + pubkey: PublicKey, peer_addr: SocketAddr, peer_manager: Arc, + logger: Arc, +) -> Result<(), Error> { + log_info!(logger, "connecting to peer: {}@{}", pubkey, peer_addr); + match lightning_net_tokio::connect_outbound(Arc::clone(&peer_manager), pubkey, peer_addr).await + { + Some(connection_closed_future) => { + let mut connection_closed_future = Box::pin(connection_closed_future); + loop { + match futures::poll!(&mut connection_closed_future) { + std::task::Poll::Ready(_) => { + log_info!(logger, "peer connection closed: {}@{}", pubkey, peer_addr); + return Err(Error::ConnectionFailed); + } + std::task::Poll::Pending => {} + } + // Avoid blocking the tokio context by sleeping a bit + match peer_manager.get_peer_node_ids().iter().find(|id| **id == pubkey) { + Some(_) => return Ok(()), + None => tokio::time::sleep(Duration::from_millis(10)).await, + } + } + } + None => { + log_error!(logger, "failed to connect to peer: {}@{}", pubkey, peer_addr); + Err(Error::ConnectionFailed) + } + } +} + +// +// Structs wrapping the particular information which should easily be +// understandable, parseable, and transformable, i.e., we'll try to avoid +// exposing too many technical detail here. +/// Represents a payment. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct PaymentInfo { + /// The pre-image used by the payment. + pub preimage: Option, + /// The secret used by the payment. + pub secret: Option, + /// The status of the payment. + pub status: PaymentStatus, + /// The amount transferred. + pub amount_msat: Option, +} + +/// Represents the current status of a payment. +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum PaymentStatus { + /// The payment is still pending. + Pending, + /// The payment suceeded. + Succeeded, + /// The payment failed. + Failed, +} + +type ChainMonitor = chainmonitor::ChainMonitor< + InMemorySigner, + Arc>>, + Arc>, + Arc>, + Arc, + Arc, +>; + +pub(crate) type PeerManager = lightning::ln::peer_handler::PeerManager< + SocketDescriptor, + Arc, + Arc, + Arc, + Arc, + IgnoringMessageHandler, +>; + +pub(crate) type ChannelManager = lightning::ln::channelmanager::ChannelManager< + Arc, + Arc>, + Arc>, + Arc>, + Arc, +>; + +pub(crate) type KeysManager = WalletKeysManager; + +type InvoicePayer = payment::InvoicePayer, Router, Arc, F>; + +type Router = DefaultRouter, Arc, Arc>>; +type Scorer = ProbabilisticScorer, Arc>; + +type GossipSync = + P2PGossipSync, Arc, Arc>; + +pub(crate) type NetworkGraph = gossip::NetworkGraph>; + +pub(crate) type PaymentInfoStorage = Mutex>; + +pub(crate) type OnionMessenger = lightning::onion_message::OnionMessenger< + Arc>, + Arc, + IgnoringMessageHandler, +>; + +impl UniffiCustomTypeConverter for PublicKey { + type Builtin = String; + + fn into_custom(val: Self::Builtin) -> uniffi::Result { + if let Ok(key) = PublicKey::from_str(&val) { + return Ok(key); + } + + Err(Error::PublicKeyInvalid.into()) + } + + fn from_custom(obj: Self) -> Self::Builtin { + obj.to_string() + } +} + +impl UniffiCustomTypeConverter for Address { + type Builtin = String; + + fn into_custom(val: Self::Builtin) -> uniffi::Result { + if let Ok(addr) = Address::from_str(&val) { + return Ok(addr); + } + + Err(Error::AddressInvalid.into()) + } + + fn from_custom(obj: Self) -> Self::Builtin { + obj.to_string() + } +} + +impl UniffiCustomTypeConverter for Invoice { + type Builtin = String; + + fn into_custom(val: Self::Builtin) -> uniffi::Result { + if let Ok(signed) = val.parse::() { + if let Ok(invoice) = Invoice::from_signed(signed) { + return Ok(invoice); + } + } + + Err(Error::InvoiceInvalid.into()) + } + + fn from_custom(obj: Self) -> Self::Builtin { + obj.to_string() + } +} + +impl UniffiCustomTypeConverter for PaymentHash { + type Builtin = String; + + fn into_custom(val: Self::Builtin) -> uniffi::Result { + if let Ok(hash) = Sha256::from_str(&val) { + Ok(PaymentHash(hash.into_inner())) + } else { + Err(Error::PaymentHashInvalid.into()) + } + } + + fn from_custom(obj: Self) -> Self::Builtin { + Sha256::from_slice(&obj.0).unwrap().to_string() + } +} + +#[derive(Debug, Clone, PartialEq)] +pub struct ChannelId([u8; 32]); + +impl UniffiCustomTypeConverter for ChannelId { + type Builtin = String; + + fn into_custom(val: Self::Builtin) -> uniffi::Result { + if let Some(hex_vec) = hex_utils::to_vec(&val) { + if hex_vec.len() == 32 { + let mut channel_id = [0u8; 32]; + channel_id.copy_from_slice(&hex_vec[..]); + return Ok(Self(channel_id)); + } + } + Err(Error::ChannelIdInvalid.into()) + } + + fn from_custom(obj: Self) -> Self::Builtin { + hex_utils::to_string(&obj.0) + } +} + +#[derive(Debug, Clone, PartialEq)] +pub struct UserChannelId(u128); + +impl UniffiCustomTypeConverter for UserChannelId { + type Builtin = String; + + fn into_custom(val: Self::Builtin) -> uniffi::Result { + Ok(UserChannelId(u128::from_str(&val).map_err(|_| Error::ChannelIdInvalid)?)) + } + + fn from_custom(obj: Self) -> Self::Builtin { + obj.0.to_string() + } +} diff --git a/src/logger.rs b/src/logger.rs index 317f294b4..5141c60bf 100644 --- a/src/logger.rs +++ b/src/logger.rs @@ -1,6 +1,7 @@ pub(crate) use lightning::util::logger::Logger; use lightning::util::logger::Record; use lightning::util::ser::Writer; +pub(crate) use lightning::{log_error, log_given_level, log_info, log_internal, log_trace}; use chrono::Utc; @@ -39,74 +40,3 @@ impl Logger for FilesystemLogger { .unwrap(); } } - -macro_rules! log_internal { - ($logger: expr, $lvl:expr, $($arg:tt)+) => ( - $logger.log(&lightning::util::logger::Record::new($lvl, format_args!($($arg)+), module_path!(), file!(), line!())) - ); -} -pub(crate) use log_internal; - -macro_rules! log_given_level { - ($logger: expr, $lvl:expr, $($arg:tt)+) => ( - match $lvl { - #[cfg(not(any(feature = "max_level_off")))] - lightning::util::logger::Level::Error => log_internal!($logger, $lvl, $($arg)*), - #[cfg(not(any(feature = "max_level_off", feature = "max_level_error")))] - lightning::util::logger::Level::Warn => log_internal!($logger, $lvl, $($arg)*), - #[cfg(not(any(feature = "max_level_off", feature = "max_level_error", feature = "max_level_warn")))] - lightning::util::logger::Level::Info => log_internal!($logger, $lvl, $($arg)*), - #[cfg(not(any(feature = "max_level_off", feature = "max_level_error", feature = "max_level_warn", feature = "max_level_info")))] - lightning::util::logger::Level::Debug => log_internal!($logger, $lvl, $($arg)*), - #[cfg(not(any(feature = "max_level_off", feature = "max_level_error", feature = "max_level_warn", feature = "max_level_info", feature = "max_level_debug")))] - lightning::util::logger::Level::Trace => log_internal!($logger, $lvl, $($arg)*), - #[cfg(not(any(feature = "max_level_off", feature = "max_level_error", feature = "max_level_warn", feature = "max_level_info", feature = "max_level_debug", feature = "max_level_trace")))] - lightning::util::logger::Level::Gossip => log_internal!($logger, $lvl, $($arg)*), - - #[cfg(any(feature = "max_level_off", feature = "max_level_error", feature = "max_level_warn", feature = "max_level_info", feature = "max_level_debug", feature = "max_level_trace"))] - _ => { - // The level is disabled at compile-time - }, - } - ); -} -pub(crate) use log_given_level; - -#[allow(unused_macros)] -macro_rules! log_error { - ($logger: expr, $($arg:tt)*) => ( - log_given_level!($logger, lightning::util::logger::Level::Error, $($arg)*) - ) -} -pub(crate) use log_error; - -#[allow(unused_macros)] -macro_rules! log_warn { - ($logger: expr, $($arg:tt)*) => ( - log_given_level!($logger, lightning::util::logger::Level::Warn, $($arg)*) - ) -} -pub(crate) use log_warn; - -#[allow(unused_macros)] -macro_rules! log_info { - ($logger: expr, $($arg:tt)*) => ( - log_given_level!($logger, lightning::util::logger::Level::Info, $($arg)*) - ) -} -pub(crate) use log_info; - -#[allow(unused_macros)] -macro_rules! log_debug { - ($logger: expr, $($arg:tt)*) => ( - log_given_level!($logger, lightning::util::logger::Level::Debug, $($arg)*) - ) -} - -#[allow(unused_macros)] -macro_rules! log_trace { - ($logger: expr, $($arg:tt)*) => ( - log_given_level!($logger, lightning::util::logger::Level::Trace, $($arg)*) - ) -} -pub(crate) use log_trace; diff --git a/src/peer_store.rs b/src/peer_store.rs new file mode 100644 index 000000000..d8a856e2f --- /dev/null +++ b/src/peer_store.rs @@ -0,0 +1,172 @@ +use crate::hex_utils; +use crate::Error; + +use lightning::util::persist::KVStorePersister; +use lightning::util::ser::{Readable, ReadableArgs, Writeable, Writer}; + +use bitcoin::secp256k1::PublicKey; + +use std::convert::TryFrom; +use std::net::{IpAddr, SocketAddr, ToSocketAddrs}; +use std::sync::{Arc, RwLock}; + +/// The peer information will be persisted under this key. +pub(crate) const PEER_INFO_PERSISTENCE_KEY: &str = "peers"; + +pub(crate) struct PeerInfoStorage { + peers: RwLock, + persister: Arc, +} + +impl PeerInfoStorage { + pub(crate) fn new(persister: Arc) -> Self { + let peers = RwLock::new(PeerInfoStorageSerWrapper(Vec::new())); + Self { peers, persister } + } + + pub(crate) fn add_peer(&self, peer_info: PeerInfo) -> Result<(), Error> { + let mut locked_peers = self.peers.write().unwrap(); + + // Check if we have the peer. If so, either update it or do nothing. + for stored_info in locked_peers.0.iter_mut() { + if stored_info.pubkey == peer_info.pubkey { + if stored_info.address != peer_info.address { + stored_info.address = peer_info.address; + } + return Ok(()); + } + } + + locked_peers.0.push(peer_info); + self.persister + .persist(PEER_INFO_PERSISTENCE_KEY, &*locked_peers) + .map_err(|_| Error::PersistenceFailed)?; + + return Ok(()); + } + + pub(crate) fn remove_peer(&self, peer_pubkey: &PublicKey) -> Result<(), Error> { + let mut locked_peers = self.peers.write().unwrap(); + + locked_peers.0.retain(|info| info.pubkey != *peer_pubkey); + + self.persister + .persist(PEER_INFO_PERSISTENCE_KEY, &*locked_peers) + .map_err(|_| Error::PersistenceFailed)?; + + return Ok(()); + } + + pub(crate) fn peers(&self) -> Vec { + self.peers.read().unwrap().0.clone() + } +} + +impl ReadableArgs> for PeerInfoStorage { + #[inline] + fn read( + reader: &mut R, persister: Arc, + ) -> Result { + let peers: RwLock = RwLock::new(Readable::read(reader)?); + Ok(Self { peers, persister }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct PeerInfoStorageSerWrapper(Vec); + +impl Readable for PeerInfoStorageSerWrapper { + fn read( + reader: &mut R, + ) -> Result { + let len: u16 = Readable::read(reader)?; + let mut peers = Vec::with_capacity(len as usize); + for _ in 0..len { + peers.push(Readable::read(reader)?); + } + Ok(PeerInfoStorageSerWrapper(peers)) + } +} + +impl Writeable for PeerInfoStorageSerWrapper { + fn write(&self, writer: &mut W) -> Result<(), lightning::io::Error> { + (self.0.len() as u16).write(writer)?; + for e in self.0.iter() { + e.write(writer)?; + } + Ok(()) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct PeerInfo { + pub pubkey: PublicKey, + pub address: SocketAddr, +} + +impl Readable for PeerInfo { + fn read( + reader: &mut R, + ) -> Result { + let pubkey = Readable::read(reader)?; + + let ip_type: u8 = Readable::read(reader)?; + let ip_addr = if ip_type == 0 { + let octets: [u8; 4] = Readable::read(reader)?; + IpAddr::from(octets) + } else { + let octets: [u8; 16] = Readable::read(reader)?; + IpAddr::from(octets) + }; + + let port: u16 = Readable::read(reader)?; + + let address = SocketAddr::new(ip_addr, port); + + Ok(PeerInfo { pubkey, address }) + } +} + +impl Writeable for PeerInfo { + fn write(&self, writer: &mut W) -> Result<(), lightning::io::Error> { + self.pubkey.write(writer)?; + + let ip_type: u8 = if self.address.ip().is_ipv4() { 0 } else { 1 }; + ip_type.write(writer)?; + + let octets = match self.address.ip() { + IpAddr::V4(ip) => ip.octets().to_vec(), + IpAddr::V6(ip) => ip.octets().to_vec(), + }; + octets.write(writer)?; + + self.address.port().write(writer)?; + + Ok(()) + } +} + +impl TryFrom for PeerInfo { + type Error = Error; + + fn try_from(peer_pubkey_and_ip_addr: String) -> Result { + let mut pubkey_and_addr = peer_pubkey_and_ip_addr.split("@"); + let pubkey = pubkey_and_addr.next(); + let peer_addr_str = pubkey_and_addr.next(); + if pubkey.is_none() || peer_addr_str.is_none() { + return Err(Error::PeerInfoParseFailed); + } + + let peer_addr = peer_addr_str.unwrap().to_socket_addrs().map(|mut r| r.next()); + if peer_addr.is_err() || peer_addr.as_ref().unwrap().is_none() { + return Err(Error::PeerInfoParseFailed); + } + + let pubkey = hex_utils::to_compressed_pubkey(pubkey.unwrap()); + if pubkey.is_none() { + return Err(Error::PeerInfoParseFailed); + } + + Ok(PeerInfo { pubkey: pubkey.unwrap(), address: peer_addr.unwrap().unwrap() }) + } +} diff --git a/src/tests/functional_tests.rs b/src/tests/functional_tests.rs new file mode 100644 index 000000000..d66f8cd19 --- /dev/null +++ b/src/tests/functional_tests.rs @@ -0,0 +1,200 @@ +use crate::tests::test_utils::expect_event; +use crate::{Builder, Config, Event}; + +use bitcoin::{Address, Amount}; +use bitcoind::bitcoincore_rpc::RpcApi; +use electrsd::bitcoind::bitcoincore_rpc::bitcoincore_rpc_json::AddressType; +use electrsd::{bitcoind, bitcoind::BitcoinD, ElectrsD}; +use electrum_client::ElectrumApi; + +use once_cell::sync::OnceCell; +use rand::distributions::Alphanumeric; +use rand::{thread_rng, Rng}; + +use std::env; +use std::sync::Mutex; +use std::time::Duration; + +static BITCOIND: OnceCell = OnceCell::new(); +static ELECTRSD: OnceCell = OnceCell::new(); +static PREMINE: OnceCell<()> = OnceCell::new(); +static MINER_LOCK: Mutex<()> = Mutex::new(()); + +fn get_bitcoind() -> &'static BitcoinD { + BITCOIND.get_or_init(|| { + let bitcoind_exe = + env::var("BITCOIND_EXE").ok().or_else(|| bitcoind::downloaded_exe_path().ok()).expect( + "you need to provide an env var BITCOIND_EXE or specify a bitcoind version feature", + ); + let mut conf = bitcoind::Conf::default(); + conf.network = "regtest"; + BitcoinD::with_conf(bitcoind_exe, &conf).unwrap() + }) +} + +fn get_electrsd() -> &'static ElectrsD { + ELECTRSD.get_or_init(|| { + let bitcoind = get_bitcoind(); + let electrs_exe = + env::var("ELECTRS_EXE").ok().or_else(electrsd::downloaded_exe_path).expect( + "you need to provide env var ELECTRS_EXE or specify an electrsd version feature", + ); + let mut conf = electrsd::Conf::default(); + conf.http_enabled = true; + conf.network = "regtest"; + ElectrsD::with_conf(electrs_exe, &bitcoind, &conf).unwrap() + }) +} + +fn generate_blocks_and_wait(num: usize) { + let _miner = MINER_LOCK.lock().unwrap(); + let cur_height = get_bitcoind().client.get_block_count().unwrap(); + let address = + get_bitcoind().client.get_new_address(Some("test"), Some(AddressType::Legacy)).unwrap(); + let _block_hashes = get_bitcoind().client.generate_to_address(num as u64, &address).unwrap(); + wait_for_block(cur_height as usize + num); +} + +fn wait_for_block(min_height: usize) { + let mut header = get_electrsd().client.block_headers_subscribe().unwrap(); + loop { + if header.height >= min_height { + break; + } + header = exponential_backoff_poll(|| { + get_electrsd().trigger().unwrap(); + get_electrsd().client.ping().unwrap(); + get_electrsd().client.block_headers_pop().unwrap() + }); + } +} + +fn exponential_backoff_poll(mut poll: F) -> T +where + F: FnMut() -> Option, +{ + let mut delay = Duration::from_millis(64); + loop { + match poll() { + Some(data) => break data, + None if delay.as_millis() < 512 => delay = delay.mul_f32(2.0), + None => {} + } + + std::thread::sleep(delay); + } +} + +fn premine_and_distribute_funds(addrs: Vec
, amount: Amount) { + PREMINE.get_or_init(|| { + generate_blocks_and_wait(101); + for addr in addrs { + get_bitcoind() + .client + .send_to_address(&addr, amount, None, None, None, None, None, None) + .unwrap(); + } + generate_blocks_and_wait(1); + }); +} + +fn rand_config() -> Config { + let mut config = Config::default(); + + let esplora_url = get_electrsd().esplora_url.as_ref().unwrap(); + + println!("Setting esplora server URL: {}", esplora_url); + config.esplora_server_url = format!("http://{}", esplora_url); + + let mut rng = thread_rng(); + let rand_dir: String = (0..7).map(|_| rng.sample(Alphanumeric) as char).collect(); + let rand_path = format!("/tmp/{}", rand_dir); + println!("Setting random LDK storage dir: {}", rand_dir); + config.storage_dir_path = rand_path; + + let rand_port: u16 = rng.gen_range(5000..8000); + println!("Setting random LDK listening port: {}", rand_port); + let listening_address = format!("127.0.0.1:{}", rand_port); + config.listening_address = Some(listening_address); + + config +} + +#[test] +fn channel_full_cycle() { + println!("== Node A =="); + let config_a = rand_config(); + let node_a = Builder::from_config(config_a).build(); + node_a.start().unwrap(); + let addr_a = node_a.new_funding_address().unwrap(); + + println!("\n== Node B =="); + let config_b = rand_config(); + let node_b = Builder::from_config(config_b).build(); + node_b.start().unwrap(); + let addr_b = node_b.new_funding_address().unwrap(); + + premine_and_distribute_funds(vec![addr_a, addr_b], Amount::from_sat(100000)); + node_a.sync_wallets().unwrap(); + node_b.sync_wallets().unwrap(); + assert_eq!(node_a.on_chain_balance().unwrap().get_spendable(), 100000); + assert_eq!(node_b.on_chain_balance().unwrap().get_spendable(), 100000); + + println!("\nA -- connect_open_channel -> B"); + let node_b_addr = + format!("{}@{}", node_b.node_id().unwrap(), node_b.listening_address().unwrap()); + node_a.connect_open_channel(&node_b_addr, 50000, true).unwrap(); + + // Wait a sec so the funding tx can 'propagate' via EsploraD to BitcoinD. + std::thread::sleep(Duration::from_secs(1)); + + println!("\n .. generating blocks, syncing wallets .. "); + generate_blocks_and_wait(6); + node_a.sync_wallets().unwrap(); + node_b.sync_wallets().unwrap(); + + let node_a_balance = node_a.on_chain_balance().unwrap(); + assert!(node_a_balance.get_spendable() < 50000); + assert!(node_a_balance.get_spendable() > 40000); + assert_eq!(node_b.on_chain_balance().unwrap().get_spendable(), 100000); + + expect_event!(node_a, ChannelReady); + + let channel_id = match node_b.next_event() { + ref e @ Event::ChannelReady { ref channel_id, .. } => { + println!("{} got event {:?}", std::stringify!(node_b), e); + node_b.event_handled(); + channel_id.clone() + } + ref e => { + panic!("{} got unexpected event!: {:?}", std::stringify!(node_b), e); + } + }; + + println!("\nB receive_payment"); + let invoice = node_b.receive_payment(Some(1000), &"asdf", 9217).unwrap(); + + println!("\nA send_payment"); + node_a.send_payment(invoice).unwrap(); + + expect_event!(node_a, PaymentSuccessful); + expect_event!(node_b, PaymentReceived); + + node_b.close_channel(&channel_id.0, &node_a.node_id().unwrap()).unwrap(); + expect_event!(node_a, ChannelClosed); + expect_event!(node_b, ChannelClosed); + + // Wait a sec so the shutdown tx can 'propagate' via EsploraD to BitcoinD. + std::thread::sleep(Duration::from_secs(1)); + + generate_blocks_and_wait(1); + node_a.sync_wallets().unwrap(); + + assert!(node_a.on_chain_balance().unwrap().get_spendable() > 90000); + assert_eq!(node_b.on_chain_balance().unwrap().get_spendable(), 100000); + + node_a.stop().unwrap(); + println!("\nA stopped"); + node_b.stop().unwrap(); + println!("\nB stopped"); +} diff --git a/src/tests/mod.rs b/src/tests/mod.rs new file mode 100644 index 000000000..5c32fa2af --- /dev/null +++ b/src/tests/mod.rs @@ -0,0 +1,2 @@ +pub mod functional_tests; +pub mod test_utils; diff --git a/src/tests/test_utils.rs b/src/tests/test_utils.rs new file mode 100644 index 000000000..4ae053361 --- /dev/null +++ b/src/tests/test_utils.rs @@ -0,0 +1,42 @@ +use lightning::util::persist::KVStorePersister; +use lightning::util::ser::Writeable; + +use std::sync::atomic::{AtomicBool, Ordering}; + +macro_rules! expect_event { + ($node: expr, $event_type: ident) => {{ + match $node.next_event() { + ref e @ Event::$event_type { .. } => { + println!("{} got event {:?}", std::stringify!($node), e); + $node.event_handled(); + } + ref e => { + panic!("{} got unexpected event!: {:?}", std::stringify!($node), e); + } + } + }}; +} + +pub(crate) use expect_event; + +pub(crate) struct TestPersister { + pending_persist: AtomicBool, +} + +impl TestPersister { + pub fn new() -> Self { + let pending_persist = AtomicBool::new(false); + Self { pending_persist } + } + + pub fn get_and_clear_pending_persist(&self) -> bool { + self.pending_persist.swap(false, Ordering::SeqCst) + } +} + +impl KVStorePersister for TestPersister { + fn persist(&self, _key: &str, _object: &W) -> std::io::Result<()> { + self.pending_persist.store(true, Ordering::SeqCst); + Ok(()) + } +} diff --git a/src/wallet.rs b/src/wallet.rs new file mode 100644 index 000000000..4007e6b02 --- /dev/null +++ b/src/wallet.rs @@ -0,0 +1,350 @@ +use crate::logger::{ + log_error, log_given_level, log_internal, log_trace, FilesystemLogger, Logger, +}; + +use crate::Error; + +use lightning::chain::chaininterface::{ + BroadcasterInterface, ConfirmationTarget, FeeEstimator, FEERATE_FLOOR_SATS_PER_KW, +}; + +use lightning::chain::keysinterface::{ + EntropySource, InMemorySigner, KeyMaterial, KeysInterface, KeysManager, NodeSigner, Recipient, + SignerProvider, SpendableOutputDescriptor, +}; +use lightning::ln::msgs::DecodeError; +use lightning::ln::script::ShutdownScript; + +use bdk::blockchain::{Blockchain, EsploraBlockchain}; +use bdk::database::BatchDatabase; +use bdk::wallet::AddressIndex; +use bdk::{FeeRate, SignOptions, SyncOptions}; + +use bitcoin::bech32::u5; +use bitcoin::secp256k1::ecdh::SharedSecret; +use bitcoin::secp256k1::ecdsa::RecoverableSignature; +use bitcoin::secp256k1::{PublicKey, Scalar, Secp256k1, SecretKey, Signing}; +use bitcoin::{Script, Transaction, TxOut}; + +use std::collections::HashMap; +use std::sync::{Arc, Mutex, RwLock}; + +pub struct Wallet +where + D: BatchDatabase, +{ + // A BDK blockchain used for wallet sync. + blockchain: EsploraBlockchain, + // A BDK on-chain wallet. + inner: Mutex>, + // A cache storing the most recently retrieved fee rate estimations. + fee_rate_cache: Mutex>, + tokio_runtime: RwLock>>, + logger: Arc, +} + +impl Wallet +where + D: BatchDatabase, +{ + pub(crate) fn new( + blockchain: EsploraBlockchain, wallet: bdk::Wallet, logger: Arc, + ) -> Self { + let inner = Mutex::new(wallet); + let fee_rate_cache = Mutex::new(HashMap::new()); + let tokio_runtime = RwLock::new(None); + Self { blockchain, inner, fee_rate_cache, tokio_runtime, logger } + } + + pub(crate) async fn sync(&self) -> Result<(), Error> { + let sync_options = SyncOptions { progress: None }; + match self.inner.lock().unwrap().sync(&self.blockchain, sync_options).await { + Ok(()) => Ok(()), + Err(e) => { + log_error!(self.logger, "Wallet sync error: {}", e); + Err(e)? + } + } + } + + pub(crate) fn set_runtime(&self, tokio_runtime: Arc) { + *self.tokio_runtime.write().unwrap() = Some(tokio_runtime); + } + + pub(crate) fn drop_runtime(&self) { + *self.tokio_runtime.write().unwrap() = None; + } + + pub(crate) fn create_funding_transaction( + &self, output_script: &Script, value_sats: u64, confirmation_target: ConfirmationTarget, + ) -> Result { + let fee_rate = self.estimate_fee_rate(confirmation_target); + + let locked_wallet = self.inner.lock().unwrap(); + let mut tx_builder = locked_wallet.build_tx(); + + tx_builder.add_recipient(output_script.clone(), value_sats).fee_rate(fee_rate).enable_rbf(); + + let mut psbt = match tx_builder.finish() { + Ok((psbt, _)) => { + log_trace!(self.logger, "Created funding PSBT: {:?}", psbt); + psbt + } + Err(err) => { + log_error!(self.logger, "Failed to create funding transaction: {}", err); + Err(err)? + } + }; + + // We double-check that no inputs try to spend non-witness outputs. As we use a SegWit + // wallet descriptor this technically shouldn't ever happen, but better safe than sorry. + for input in &psbt.inputs { + if input.witness_utxo.is_none() { + log_error!(self.logger, "Tried to spend a non-witness funding output. This must not ever happen. Panicking!"); + panic!("Tried to spend a non-witness funding output. This must not ever happen."); + } + } + + if !locked_wallet.sign(&mut psbt, SignOptions::default())? { + return Err(Error::FundingTxCreationFailed); + } + + Ok(psbt.extract_tx()) + } + + pub(crate) fn get_new_address(&self) -> Result { + let address_info = self.inner.lock().unwrap().get_address(AddressIndex::New)?; + Ok(address_info.address) + } + + #[cfg(any(test))] + pub(crate) fn get_balance(&self) -> Result { + Ok(self.inner.lock().unwrap().get_balance()?) + } + + fn estimate_fee_rate(&self, confirmation_target: ConfirmationTarget) -> FeeRate { + let mut locked_fee_rate_cache = self.fee_rate_cache.lock().unwrap(); + let num_blocks = num_blocks_from_conf_target(confirmation_target); + + // We'll fall back on this, if we really don't have any other information. + let fallback_rate = fallback_fee_from_conf_target(confirmation_target); + + let locked_runtime = self.tokio_runtime.read().unwrap(); + if locked_runtime.as_ref().is_none() { + log_error!(self.logger, "Failed to update fee rate estimation: No runtime."); + unreachable!("Failed to broadcast transaction: No runtime."); + } + + let est_fee_rate = tokio::task::block_in_place(move || { + locked_runtime + .as_ref() + .unwrap() + .handle() + .block_on(async move { self.blockchain.estimate_fee(num_blocks).await }) + }); + + match est_fee_rate { + Ok(rate) => { + locked_fee_rate_cache.insert(confirmation_target, rate); + log_trace!( + self.logger, + "Fee rate estimation updated: {} sats/kwu", + rate.fee_wu(1000) + ); + rate + } + Err(e) => { + log_error!(self.logger, "Failed to update fee rate estimation: {}", e); + *locked_fee_rate_cache.get(&confirmation_target).unwrap_or(&fallback_rate) + } + } + } +} + +impl FeeEstimator for Wallet +where + D: BatchDatabase, +{ + fn get_est_sat_per_1000_weight(&self, confirmation_target: ConfirmationTarget) -> u32 { + (self.estimate_fee_rate(confirmation_target).fee_wu(1000) as u32) + .max(FEERATE_FLOOR_SATS_PER_KW) + } +} + +impl BroadcasterInterface for Wallet +where + D: BatchDatabase, +{ + fn broadcast_transaction(&self, tx: &Transaction) { + let locked_runtime = self.tokio_runtime.read().unwrap(); + if locked_runtime.as_ref().is_none() { + log_error!(self.logger, "Failed to broadcast transaction: No runtime."); + unreachable!("Failed to broadcast transaction: No runtime."); + } + + let res = tokio::task::block_in_place(move || { + locked_runtime + .as_ref() + .unwrap() + .block_on(async move { self.blockchain.broadcast(tx).await }) + }); + + match res { + Ok(_) => {} + Err(err) => { + log_error!(self.logger, "Failed to broadcast transaction: {}", err); + } + } + } +} + +fn num_blocks_from_conf_target(confirmation_target: ConfirmationTarget) -> usize { + match confirmation_target { + ConfirmationTarget::Background => 12, + ConfirmationTarget::Normal => 6, + ConfirmationTarget::HighPriority => 3, + } +} + +fn fallback_fee_from_conf_target(confirmation_target: ConfirmationTarget) -> FeeRate { + let sats_kwu = match confirmation_target { + ConfirmationTarget::Background => FEERATE_FLOOR_SATS_PER_KW, + ConfirmationTarget::Normal => 2000, + ConfirmationTarget::HighPriority => 5000, + }; + + FeeRate::from_sat_per_kwu(sats_kwu as f32) +} + +/// Similar to [`KeysManager`], but overrides the destination and shutdown scripts so they are +/// directly spendable by the BDK wallet. +pub struct WalletKeysManager +where + D: BatchDatabase, +{ + inner: KeysManager, + wallet: Arc>, +} + +impl WalletKeysManager +where + D: BatchDatabase, +{ + /// Constructs a `WalletKeysManager` that + /// + /// See [`KeysManager::new`] for more information on `seed`, `starting_time_secs`, and + /// `starting_time_nanos`. + pub fn new( + seed: &[u8; 32], starting_time_secs: u64, starting_time_nanos: u32, wallet: Arc>, + ) -> Self { + let inner = KeysManager::new(seed, starting_time_secs, starting_time_nanos); + Self { inner, wallet } + } + + /// See [`KeysManager::spend_spendable_outputs`] for documentation on this method. + pub fn spend_spendable_outputs( + &self, descriptors: &[&SpendableOutputDescriptor], outputs: Vec, + change_destination_script: Script, feerate_sat_per_1000_weight: u32, + secp_ctx: &Secp256k1, + ) -> Result { + let only_non_static = &descriptors + .iter() + .filter(|desc| { + if let SpendableOutputDescriptor::StaticOutput { .. } = desc { + false + } else { + true + } + }) + .copied() + .collect::>(); + self.inner.spend_spendable_outputs( + only_non_static, + outputs, + change_destination_script, + feerate_sat_per_1000_weight, + secp_ctx, + ) + } +} + +impl NodeSigner for WalletKeysManager +where + D: BatchDatabase, +{ + fn get_node_secret(&self, recipient: Recipient) -> Result { + self.inner.get_node_secret(recipient) + } + + fn get_node_id(&self, recipient: Recipient) -> Result { + self.inner.get_node_id(recipient) + } + + fn ecdh( + &self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&Scalar>, + ) -> Result { + self.inner.ecdh(recipient, other_key, tweak) + } + + fn get_inbound_payment_key_material(&self) -> KeyMaterial { + self.inner.get_inbound_payment_key_material() + } + + fn sign_invoice( + &self, hrp_bytes: &[u8], invoice_data: &[u5], recipient: Recipient, + ) -> Result { + self.inner.sign_invoice(hrp_bytes, invoice_data, recipient) + } +} + +impl KeysInterface for WalletKeysManager where D: BatchDatabase {} + +impl EntropySource for WalletKeysManager +where + D: BatchDatabase, +{ + fn get_secure_random_bytes(&self) -> [u8; 32] { + self.inner.get_secure_random_bytes() + } +} + +impl SignerProvider for WalletKeysManager +where + D: BatchDatabase, +{ + type Signer = InMemorySigner; + + fn generate_channel_keys_id( + &self, inbound: bool, channel_value_satoshis: u64, user_channel_id: u128, + ) -> [u8; 32] { + self.inner.generate_channel_keys_id(inbound, channel_value_satoshis, user_channel_id) + } + + fn derive_channel_signer( + &self, channel_value_satoshis: u64, channel_keys_id: [u8; 32], + ) -> Self::Signer { + self.inner.derive_channel_signer(channel_value_satoshis, channel_keys_id) + } + + fn read_chan_signer(&self, reader: &[u8]) -> Result { + self.inner.read_chan_signer(reader) + } + + fn get_destination_script(&self) -> Script { + let address = + self.wallet.get_new_address().expect("Failed to retrieve new address from wallet."); + address.script_pubkey() + } + + fn get_shutdown_scriptpubkey(&self) -> ShutdownScript { + let address = + self.wallet.get_new_address().expect("Failed to retrieve new address from wallet."); + match address.payload { + bitcoin::util::address::Payload::WitnessProgram { version, program } => { + return ShutdownScript::new_witness_program(version, &program) + .expect("Invalid shutdown script."); + } + _ => panic!("Tried to use a non-witness address. This must not ever happen."), + } + } +} diff --git a/uniffi.toml b/uniffi.toml new file mode 100644 index 000000000..71041968a --- /dev/null +++ b/uniffi.toml @@ -0,0 +1,9 @@ +[bindings.kotlin] +package_name = "org.ldk.ldknode" +cdylib_name = "ldk_node" + +[bindings.python] +cdylib_name = "ldk_node" + +[bindings.swift] +cdylib_name = "ldk_node" diff --git a/uniffi/ldk_node.udl b/uniffi/ldk_node.udl new file mode 100644 index 000000000..77246e4b9 --- /dev/null +++ b/uniffi/ldk_node.udl @@ -0,0 +1,79 @@ +namespace ldk_node { +}; + +interface Builder { + constructor(); + Node build(); +}; + +interface Node { + [Throws=NodeError] + void start(); + [Throws=NodeError] + void stop(); + Event next_event(); + void event_handled(); + [Throws=NodeError] + PublicKey node_id(); + [Throws=NodeError] + Address new_funding_address(); + [Throws=NodeError] + void connect_open_channel([ByRef]string node_pubkey_and_address, u64 channel_amount_sats, boolean announce_channel); + [Throws=NodeError] + PaymentHash send_payment(Invoice invoice); + [Throws=NodeError] + PaymentHash send_spontaneous_payment(u64 amount_msat, [ByRef]string node_id); + [Throws=NodeError] + Invoice receive_payment(u64? amount_msat, [ByRef]string description, u32 expiry_secs); + // TODO: payment_info() +}; + +[Error] +enum NodeError { + "AlreadyRunning", + "NotRunning", + "FundingTxCreationFailed", + "ConnectionFailed", + "AddressInvalid", + "PublicKeyInvalid", + "PaymentHashInvalid", + "NonUniquePaymentHash", + "InvoiceInvalid", + "InvoiceCreationFailed", + "ChannelIdInvalid", + "RoutingFailed", + "PeerInfoParseFailed", + "ChannelCreationFailed", + "ChannelClosingFailed", + "PersistenceFailed", + "WalletOperationFailed", + "WalletSigningFailed", + "TxSyncFailed", +}; + +[Enum] +interface Event { + PaymentSuccessful( PaymentHash payment_hash ); + PaymentFailed( PaymentHash payment_hash ); + PaymentReceived( PaymentHash payment_hash, u64 amount_msat); + ChannelReady ( ChannelId channel_id, UserChannelId user_channel_id ); + ChannelClosed ( ChannelId channel_id, UserChannelId user_channel_id ); +}; + +[Custom] +typedef string PublicKey; + +[Custom] +typedef string Address; + +[Custom] +typedef string Invoice; + +[Custom] +typedef string PaymentHash; + +[Custom] +typedef string ChannelId; + +[Custom] +typedef string UserChannelId; diff --git a/uniffi_bindgen_generate.sh b/uniffi_bindgen_generate.sh new file mode 100644 index 000000000..bf912723e --- /dev/null +++ b/uniffi_bindgen_generate.sh @@ -0,0 +1,8 @@ +#!/bin/bash +uniffi-bindgen generate uniffi/ldk_node.udl --language python +uniffi-bindgen generate uniffi/ldk_node.udl --language kotlin + +uniffi-bindgen generate uniffi/ldk_node.udl --language swift +#swiftc -module-name ldk_node -emit-library -o libldk_node.dylib -emit-module -emit-module-path ./uniffi -parse-as-library -L ./target/release/ -lldk_node -Xcc -fmodule-map-file=./uniffi/ldk_nodeFFI.modulemap ./uniffi/ldk_node.swift -v +#swiftc -module-name ldk_node -emit-library -o libldk_node.dylib -emit-module -emit-module-path ./uniffi -parse-as-library -L ./target/debug/ -lldk_node -Xcc -fmodule-map-file=./uniffi/ldk_nodeFFI.modulemap ./uniffi/ldk_node.swift -v +#swiftc -module-name ldk_node -emit-library -o libldk_node.dylib -emit-module -emit-module-path ./uniffi -parse-as-library -L ./target/x86_64-apple-darwin/release/ -lldk_node -Xcc -fmodule-map-file=./uniffi/ldk_nodeFFI.modulemap ./uniffi/ldk_node.swift -v diff --git a/uniffi_bindgen_generate_kotlin.sh b/uniffi_bindgen_generate_kotlin.sh new file mode 100644 index 000000000..b33936f59 --- /dev/null +++ b/uniffi_bindgen_generate_kotlin.sh @@ -0,0 +1,13 @@ +#!/bin/bash + +# make sure you're using the uniffi-bindgen tool version 0.21.0 + +# 1. Generate the glue file +# 2. Build the native binaries +# 3. Move them both in the jvm lib +uniffi-bindgen generate uniffi/ldk_node.udl --language kotlin +cargo +nightly build --target aarch64-apple-darwin +mkdir -p ./ldk-node-jvm/lib/src/main/kotlin/org/ldk/ +mkdir -p ./ldk-node-jvm/lib/src/main/resources/darwin-aarch64/ +cp ./uniffi/org/ldk/ldknode/ldk_node.kt ./ldk-node-jvm/lib/src/main/kotlin/org/ldk/ +cp ./target/aarch64-apple-darwin/debug/libldk_node.dylib ./ldk-node-jvm/lib/src/main/resources/darwin-aarch64/libldk_node.dylib