[WIP] reorganize and remove old stuff
This commit is contained in:
Steve Myers
parent
f30558d55c
commit
091c9994fa
2
.gitignore
vendored
2
.gitignore
vendored
@ -7,4 +7,4 @@ wallet_db
|
|||||||
bdk_ffi_test
|
bdk_ffi_test
|
||||||
local.properties
|
local.properties
|
||||||
*.log
|
*.log
|
||||||
targets/kotlin/testdb
|
*.dylib
|
||||||
@ -1,7 +1,7 @@
|
|||||||
[package]
|
[package]
|
||||||
name = "uniffi_bdk"
|
name = "uniffi_bdk"
|
||||||
version = "0.1.0"
|
version = "0.1.0"
|
||||||
authors = ["Steve Myers <steve@notmandatory.org>"]
|
authors = ["Steve Myers <steve@notmandatory.org>", ""]
|
||||||
edition = "2018"
|
edition = "2018"
|
||||||
|
|
||||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||||
|
|||||||
@ -3,9 +3,9 @@ UniFFI
|
|||||||
|
|
||||||
1. cargo install uniffi_bindgen
|
1. cargo install uniffi_bindgen
|
||||||
2. cargo build
|
2. cargo build
|
||||||
3. uniffi-bindgen generate --no-format --out-dir targets/kotlin/src/main/kotlin src/bdk.udl --language kotlin
|
3. uniffi-bindgen generate --no-format --out-dir bindings/bdk-kotlin/src/main/kotlin src/bdk.udl --language kotlin
|
||||||
4. cp target/debug/libuniffi_bdk.dylib targets/kotlin/src/main/resources/darwin-x86-64
|
4. cp target/debug/libuniffi_bdk.dylib bindings/bdk-kotlin/src/main/resources/darwin-x86-64
|
||||||
5. gradle build -Djna.debug_load=true -Djna.debug_load.jna
|
5. cd bindings/bdk-kotlin; gradle build -Djna.debug_load=true -Djna.debug_load.jna
|
||||||
|
|
||||||
|
|
||||||
Setup Android build environment
|
Setup Android build environment
|
||||||
|
|||||||
28
build.sh
28
build.sh
@ -32,27 +32,27 @@ build_cc() {
|
|||||||
cc cc/bdk_ffi_test.c -o cc/bdk_ffi_test -L target/debug -l bdk_ffi -l pthread -l dl -l m
|
cc cc/bdk_ffi_test.c -o cc/bdk_ffi_test -L target/debug -l bdk_ffi -l pthread -l dl -l m
|
||||||
}
|
}
|
||||||
|
|
||||||
## copy to bdk-kotlin
|
## copy to bdk-bdk-kotlin
|
||||||
copy_lib_kotlin() {
|
copy_lib_kotlin() {
|
||||||
echo -n "Copy "
|
echo -n "Copy "
|
||||||
case $OS in
|
case $OS in
|
||||||
"Darwin")
|
"Darwin")
|
||||||
echo -n "darwin "
|
echo -n "darwin "
|
||||||
mkdir -p bdk-kotlin/jvm/src/main/resources/darwin-x86-64
|
mkdir -p bdk-bdk-kotlin/jvm/src/main/resources/darwin-x86-64
|
||||||
cp target/debug/libbdk_ffi.dylib bdk-kotlin/jvm/src/main/resources/darwin-x86-64
|
cp target/debug/libbdk_ffi.dylib bdk-bdk-kotlin/jvm/src/main/resources/darwin-x86-64
|
||||||
;;
|
;;
|
||||||
"Linux")
|
"Linux")
|
||||||
echo -n "linux "
|
echo -n "linux "
|
||||||
mkdir -p bdk-kotlin/jvm/src/main/resources/linux-x86-64
|
mkdir -p bdk-bdk-kotlin/jvm/src/main/resources/linux-x86-64
|
||||||
cp target/debug/libbdk_ffi.so bdk-kotlin/jvm/src/main/resources/linux-x86-64
|
cp target/debug/libbdk_ffi.so bdk-bdk-kotlin/jvm/src/main/resources/linux-x86-64
|
||||||
;;
|
;;
|
||||||
esac
|
esac
|
||||||
echo "libs to kotlin sub-project"
|
echo "libs to kotlin sub-project"
|
||||||
}
|
}
|
||||||
|
|
||||||
## bdk-kotlin jar
|
## bdk-bdk-kotlin jar
|
||||||
build_kotlin() {
|
build_kotlin() {
|
||||||
(cd bdk-kotlin && ./gradlew :jvm:build && ./gradlew :jvm:publishToMavenLocal)
|
(cd bdk-bdk-kotlin && ./gradlew :jvm:build && ./gradlew :jvm:publishToMavenLocal)
|
||||||
}
|
}
|
||||||
|
|
||||||
## rust android
|
## rust android
|
||||||
@ -69,27 +69,27 @@ build_android() {
|
|||||||
# IMPORTANT: make sure every target is not a substring of a different one. We check for them with grep later on
|
# IMPORTANT: make sure every target is not a substring of a different one. We check for them with grep later on
|
||||||
BUILD_TARGETS="${BUILD_TARGETS:-aarch64,armv7,x86_64,i686}"
|
BUILD_TARGETS="${BUILD_TARGETS:-aarch64,armv7,x86_64,i686}"
|
||||||
|
|
||||||
mkdir -p bdk-kotlin/android/src/main/jniLibs/ bdk-kotlin/android/src/main/jniLibs/arm64-v8a bdk-kotlin/android/src/main/jniLibs/x86_64 bdk-kotlin/android/src/main/jniLibs/armeabi-v7a bdk-kotlin/android/src/main/jniLibs/x86
|
mkdir -p bdk-bdk-kotlin/android/src/main/jniLibs/ bdk-bdk-kotlin/android/src/main/jniLibs/arm64-v8a bdk-bdk-kotlin/android/src/main/jniLibs/x86_64 bdk-bdk-kotlin/android/src/main/jniLibs/armeabi-v7a bdk-bdk-kotlin/android/src/main/jniLibs/x86
|
||||||
|
|
||||||
if echo $BUILD_TARGETS | grep "aarch64"; then
|
if echo $BUILD_TARGETS | grep "aarch64"; then
|
||||||
CARGO_TARGET_AARCH64_LINUX_ANDROID_LINKER="aarch64-linux-android21-clang" CC="aarch64-linux-android21-clang" cargo build --target=aarch64-linux-android
|
CARGO_TARGET_AARCH64_LINUX_ANDROID_LINKER="aarch64-linux-android21-clang" CC="aarch64-linux-android21-clang" cargo build --target=aarch64-linux-android
|
||||||
cp target/aarch64-linux-android/debug/libbdk_ffi.so bdk-kotlin/android/src/main/jniLibs/arm64-v8a
|
cp target/aarch64-linux-android/debug/libbdk_ffi.so bdk-bdk-kotlin/android/src/main/jniLibs/arm64-v8a
|
||||||
fi
|
fi
|
||||||
if echo $BUILD_TARGETS | grep "x86_64"; then
|
if echo $BUILD_TARGETS | grep "x86_64"; then
|
||||||
CARGO_TARGET_X86_64_LINUX_ANDROID_LINKER="x86_64-linux-android21-clang" CC="x86_64-linux-android21-clang" cargo build --target=x86_64-linux-android
|
CARGO_TARGET_X86_64_LINUX_ANDROID_LINKER="x86_64-linux-android21-clang" CC="x86_64-linux-android21-clang" cargo build --target=x86_64-linux-android
|
||||||
cp target/x86_64-linux-android/debug/libbdk_ffi.so bdk-kotlin/android/src/main/jniLibs/x86_64
|
cp target/x86_64-linux-android/debug/libbdk_ffi.so bdk-bdk-kotlin/android/src/main/jniLibs/x86_64
|
||||||
fi
|
fi
|
||||||
if echo $BUILD_TARGETS | grep "armv7"; then
|
if echo $BUILD_TARGETS | grep "armv7"; then
|
||||||
CARGO_TARGET_ARMV7_LINUX_ANDROIDEABI_LINKER="armv7a-linux-androideabi21-clang" CC="armv7a-linux-androideabi21-clang" cargo build --target=armv7-linux-androideabi
|
CARGO_TARGET_ARMV7_LINUX_ANDROIDEABI_LINKER="armv7a-linux-androideabi21-clang" CC="armv7a-linux-androideabi21-clang" cargo build --target=armv7-linux-androideabi
|
||||||
cp target/armv7-linux-androideabi/debug/libbdk_ffi.so bdk-kotlin/android/src/main/jniLibs/armeabi-v7a
|
cp target/armv7-linux-androideabi/debug/libbdk_ffi.so bdk-bdk-kotlin/android/src/main/jniLibs/armeabi-v7a
|
||||||
fi
|
fi
|
||||||
if echo $BUILD_TARGETS | grep "i686"; then
|
if echo $BUILD_TARGETS | grep "i686"; then
|
||||||
CARGO_TARGET_I686_LINUX_ANDROID_LINKER="i686-linux-android21-clang" CC="i686-linux-android21-clang" cargo build --target=i686-linux-android
|
CARGO_TARGET_I686_LINUX_ANDROID_LINKER="i686-linux-android21-clang" CC="i686-linux-android21-clang" cargo build --target=i686-linux-android
|
||||||
cp target/i686-linux-android/debug/libbdk_ffi.so bdk-kotlin/android/src/main/jniLibs/x86
|
cp target/i686-linux-android/debug/libbdk_ffi.so bdk-bdk-kotlin/android/src/main/jniLibs/x86
|
||||||
fi
|
fi
|
||||||
|
|
||||||
# bdk-kotlin aar
|
# bdk-bdk-kotlin aar
|
||||||
(cd bdk-kotlin && ./gradlew :android:build && ./gradlew :android:publishToMavenLocal)
|
(cd bdk-bdk-kotlin && ./gradlew :android:build && ./gradlew :android:publishToMavenLocal)
|
||||||
}
|
}
|
||||||
|
|
||||||
OS=$(uname)
|
OS=$(uname)
|
||||||
|
|||||||
134
src/error.rs
134
src/error.rs
@ -1,134 +0,0 @@
|
|||||||
use bdk::Error;
|
|
||||||
use thiserror::Error;
|
|
||||||
|
|
||||||
#[derive(Error, Debug)]
|
|
||||||
pub enum FfiError {
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
None,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
InvalidU32Bytes,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
Generic,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
ScriptDoesntHaveAddressForm,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
NoRecipients,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
NoUtxosSelected,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
OutputBelowDustLimit,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
InsufficientFunds,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
BnBTotalTriesExceeded,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
BnBNoExactMatch,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
UnknownUtxo,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
TransactionNotFound,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
TransactionConfirmed,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
IrreplaceableTransaction,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
FeeRateTooLow,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
FeeTooLow,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
FeeRateUnavailable,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
MissingKeyOrigin,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
Key,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
ChecksumMismatch,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
SpendingPolicyRequired,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
InvalidPolicyPathError,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
Signer,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
InvalidNetwork,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
InvalidProgressValue,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
ProgressUpdateError,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
InvalidOutpoint,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
Descriptor,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
AddressValidator,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
Encode,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
Miniscript,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
Bip32,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
Secp256k1,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
Json,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
Hex,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
Psbt,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
PsbtParse,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
Electrum,
|
|
||||||
// Esplora,
|
|
||||||
// CompactFilters,
|
|
||||||
#[error("data store disconnected")]
|
|
||||||
Sled,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<bdk::Error> for FfiError {
|
|
||||||
fn from(error: bdk::Error) -> Self {
|
|
||||||
match error {
|
|
||||||
Error::InvalidU32Bytes(_) => FfiError::InvalidU32Bytes,
|
|
||||||
Error::Generic(_) => FfiError::Generic,
|
|
||||||
Error::ScriptDoesntHaveAddressForm => FfiError::ScriptDoesntHaveAddressForm,
|
|
||||||
Error::NoRecipients => FfiError::NoRecipients,
|
|
||||||
Error::NoUtxosSelected => FfiError::NoUtxosSelected,
|
|
||||||
Error::OutputBelowDustLimit(_) => FfiError::OutputBelowDustLimit,
|
|
||||||
Error::InsufficientFunds { .. } => FfiError::InsufficientFunds,
|
|
||||||
Error::BnBTotalTriesExceeded => FfiError::BnBTotalTriesExceeded,
|
|
||||||
Error::BnBNoExactMatch => FfiError::BnBNoExactMatch,
|
|
||||||
Error::UnknownUtxo => FfiError::UnknownUtxo,
|
|
||||||
Error::TransactionNotFound => FfiError::TransactionNotFound,
|
|
||||||
Error::TransactionConfirmed => FfiError::TransactionConfirmed,
|
|
||||||
Error::IrreplaceableTransaction => FfiError::IrreplaceableTransaction,
|
|
||||||
Error::FeeRateTooLow { .. } => FfiError::FeeRateTooLow,
|
|
||||||
Error::FeeTooLow { .. } => FfiError::FeeTooLow,
|
|
||||||
Error::FeeRateUnavailable => FfiError::FeeRateUnavailable,
|
|
||||||
Error::MissingKeyOrigin(_) => FfiError::MissingKeyOrigin,
|
|
||||||
Error::Key(_) => FfiError::Key,
|
|
||||||
Error::ChecksumMismatch => FfiError::ChecksumMismatch,
|
|
||||||
Error::SpendingPolicyRequired(_) => FfiError::SpendingPolicyRequired,
|
|
||||||
Error::InvalidPolicyPathError(_) => FfiError::InvalidPolicyPathError,
|
|
||||||
Error::Signer(_) => FfiError::Signer,
|
|
||||||
Error::InvalidNetwork { .. } => FfiError::InvalidNetwork,
|
|
||||||
Error::InvalidProgressValue(_) => FfiError::InvalidProgressValue,
|
|
||||||
Error::ProgressUpdateError => FfiError::ProgressUpdateError,
|
|
||||||
Error::InvalidOutpoint(_) => FfiError::InvalidOutpoint,
|
|
||||||
Error::Descriptor(_) => FfiError::Descriptor,
|
|
||||||
Error::AddressValidator(_) => FfiError::AddressValidator,
|
|
||||||
Error::Encode(_) => FfiError::Encode,
|
|
||||||
Error::Miniscript(_) => FfiError::Miniscript,
|
|
||||||
Error::Bip32(_) => FfiError::Bip32,
|
|
||||||
Error::Secp256k1(_) => FfiError::Secp256k1,
|
|
||||||
Error::Json(_) => FfiError::Json,
|
|
||||||
Error::Hex(_) => FfiError::Hex,
|
|
||||||
Error::Psbt(_) => FfiError::Psbt,
|
|
||||||
Error::PsbtParse(_) => FfiError::PsbtParse,
|
|
||||||
Error::Electrum(_) => FfiError::Electrum,
|
|
||||||
// Error::Esplora(_) => JniError::Esplora,
|
|
||||||
// Error::CompactFilters(_) => JniError::CompactFilters,
|
|
||||||
// Error::Rpc(_) => JniError::Rpc,
|
|
||||||
Error::Sled(_) => FfiError::Sled,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
40
src/types.rs
40
src/types.rs
@ -1,40 +0,0 @@
|
|||||||
use crate::error::FfiError;
|
|
||||||
use ::safer_ffi::prelude::*;
|
|
||||||
use safer_ffi::char_p::char_p_boxed;
|
|
||||||
|
|
||||||
#[derive_ReprC]
|
|
||||||
#[repr(C)]
|
|
||||||
#[derive(Debug)]
|
|
||||||
pub struct FfiResult<T> {
|
|
||||||
pub ok: T,
|
|
||||||
pub err: FfiError,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive_ReprC]
|
|
||||||
#[repr(C)]
|
|
||||||
#[derive(Debug)]
|
|
||||||
pub struct FfiResultVoid {
|
|
||||||
pub err: FfiError,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[ffi_export]
|
|
||||||
fn free_string_result(string_result: FfiResult<char_p_boxed>) {
|
|
||||||
drop(string_result)
|
|
||||||
}
|
|
||||||
|
|
||||||
#[ffi_export]
|
|
||||||
fn free_void_result(void_result: FfiResultVoid) {
|
|
||||||
drop(void_result)
|
|
||||||
}
|
|
||||||
|
|
||||||
#[ffi_export]
|
|
||||||
fn free_uint64_result(void_result: FfiResult<u64>) {
|
|
||||||
drop(void_result)
|
|
||||||
}
|
|
||||||
|
|
||||||
// TODO do we need this? remove?
|
|
||||||
/// Free a Rust-allocated string
|
|
||||||
#[ffi_export]
|
|
||||||
fn free_string(string: Option<char_p_boxed>) {
|
|
||||||
drop(string)
|
|
||||||
}
|
|
||||||
@ -1,602 +0,0 @@
|
|||||||
// This file was autogenerated by some hot garbage in the `uniffi` crate.
|
|
||||||
// Trust me, you don't want to mess with it!
|
|
||||||
|
|
||||||
@file:Suppress("NAME_SHADOWING")
|
|
||||||
|
|
||||||
package uniffi.bdk;
|
|
||||||
|
|
||||||
// Common helper code.
|
|
||||||
//
|
|
||||||
// Ideally this would live in a separate .kt file where it can be unittested etc
|
|
||||||
// in isolation, and perhaps even published as a re-useable package.
|
|
||||||
//
|
|
||||||
// However, it's important that the detils of how this helper code works (e.g. the
|
|
||||||
// way that different builtin types are passed across the FFI) exactly match what's
|
|
||||||
// expected by the Rust code on the other side of the interface. In practice right
|
|
||||||
// now that means coming from the exact some version of `uniffi` that was used to
|
|
||||||
// compile the Rust component. The easiest way to ensure this is to bundle the Kotlin
|
|
||||||
// helpers directly inline like we're doing here.
|
|
||||||
|
|
||||||
import com.sun.jna.Library
|
|
||||||
import com.sun.jna.Native
|
|
||||||
import com.sun.jna.Pointer
|
|
||||||
import com.sun.jna.Structure
|
|
||||||
import java.nio.ByteBuffer
|
|
||||||
import java.nio.ByteOrder
|
|
||||||
import java.util.concurrent.atomic.AtomicLong
|
|
||||||
import java.util.concurrent.atomic.AtomicBoolean
|
|
||||||
import java.util.concurrent.atomic.AtomicReference
|
|
||||||
import java.util.concurrent.locks.ReentrantLock
|
|
||||||
import kotlin.concurrent.withLock
|
|
||||||
|
|
||||||
// This is a helper for safely working with byte buffers returned from the Rust code.
|
|
||||||
// A rust-owned buffer is represented by its capacity, its current length, and a
|
|
||||||
// pointer to the underlying data.
|
|
||||||
|
|
||||||
@Structure.FieldOrder("capacity", "len", "data")
|
|
||||||
open class RustBuffer : Structure() {
|
|
||||||
@JvmField var capacity: Int = 0
|
|
||||||
@JvmField var len: Int = 0
|
|
||||||
@JvmField var data: Pointer? = null
|
|
||||||
|
|
||||||
class ByValue : RustBuffer(), Structure.ByValue
|
|
||||||
class ByReference : RustBuffer(), Structure.ByReference
|
|
||||||
|
|
||||||
companion object {
|
|
||||||
internal fun alloc(size: Int = 0) = rustCall() { status ->
|
|
||||||
_UniFFILib.INSTANCE.ffi_bdk_ed55_rustbuffer_alloc(size, status)
|
|
||||||
}
|
|
||||||
|
|
||||||
internal fun free(buf: RustBuffer.ByValue) = rustCall() { status ->
|
|
||||||
_UniFFILib.INSTANCE.ffi_bdk_ed55_rustbuffer_free(buf, status)
|
|
||||||
}
|
|
||||||
|
|
||||||
internal fun reserve(buf: RustBuffer.ByValue, additional: Int) = rustCall() { status ->
|
|
||||||
_UniFFILib.INSTANCE.ffi_bdk_ed55_rustbuffer_reserve(buf, additional, status)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@Suppress("TooGenericExceptionThrown")
|
|
||||||
fun asByteBuffer() =
|
|
||||||
this.data?.getByteBuffer(0, this.len.toLong())?.also {
|
|
||||||
it.order(ByteOrder.BIG_ENDIAN)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// This is a helper for safely passing byte references into the rust code.
|
|
||||||
// It's not actually used at the moment, because there aren't many things that you
|
|
||||||
// can take a direct pointer to in the JVM, and if we're going to copy something
|
|
||||||
// then we might as well copy it into a `RustBuffer`. But it's here for API
|
|
||||||
// completeness.
|
|
||||||
|
|
||||||
@Structure.FieldOrder("len", "data")
|
|
||||||
open class ForeignBytes : Structure() {
|
|
||||||
@JvmField var len: Int = 0
|
|
||||||
@JvmField var data: Pointer? = null
|
|
||||||
|
|
||||||
class ByValue : ForeignBytes(), Structure.ByValue
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// A helper for structured writing of data into a `RustBuffer`.
|
|
||||||
// This is very similar to `java.nio.ByteBuffer` but it knows how to grow
|
|
||||||
// the underlying `RustBuffer` on demand.
|
|
||||||
//
|
|
||||||
// TODO: we should benchmark writing things into a `RustBuffer` versus building
|
|
||||||
// up a bytearray and then copying it across.
|
|
||||||
|
|
||||||
class RustBufferBuilder() {
|
|
||||||
var rbuf = RustBuffer.ByValue()
|
|
||||||
var bbuf: ByteBuffer? = null
|
|
||||||
|
|
||||||
init {
|
|
||||||
val rbuf = RustBuffer.alloc(16) // Totally arbitrary initial size
|
|
||||||
rbuf.writeField("len", 0)
|
|
||||||
this.setRustBuffer(rbuf)
|
|
||||||
}
|
|
||||||
|
|
||||||
internal fun setRustBuffer(rbuf: RustBuffer.ByValue) {
|
|
||||||
this.rbuf = rbuf
|
|
||||||
this.bbuf = this.rbuf.data?.getByteBuffer(0, this.rbuf.capacity.toLong())?.also {
|
|
||||||
it.order(ByteOrder.BIG_ENDIAN)
|
|
||||||
it.position(rbuf.len)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fun finalize() : RustBuffer.ByValue {
|
|
||||||
val rbuf = this.rbuf
|
|
||||||
// Ensure that the JVM-level field is written through to native memory
|
|
||||||
// before turning the buffer, in case its recipient uses it in a context
|
|
||||||
// JNA doesn't apply its automatic synchronization logic.
|
|
||||||
rbuf.writeField("len", this.bbuf!!.position())
|
|
||||||
this.setRustBuffer(RustBuffer.ByValue())
|
|
||||||
return rbuf
|
|
||||||
}
|
|
||||||
|
|
||||||
fun discard() {
|
|
||||||
val rbuf = this.finalize()
|
|
||||||
RustBuffer.free(rbuf)
|
|
||||||
}
|
|
||||||
|
|
||||||
internal fun reserve(size: Int, write: (ByteBuffer) -> Unit) {
|
|
||||||
// TODO: this will perform two checks to ensure we're not overflowing the buffer:
|
|
||||||
// one here where we check if it needs to grow, and another when we call a write
|
|
||||||
// method on the ByteBuffer. It might be cheaper to use exception-driven control-flow
|
|
||||||
// here, trying the write and growing if it throws a `BufferOverflowException`.
|
|
||||||
// Benchmarking needed.
|
|
||||||
if (this.bbuf!!.position() + size > this.rbuf.capacity) {
|
|
||||||
rbuf.writeField("len", this.bbuf!!.position())
|
|
||||||
this.setRustBuffer(RustBuffer.reserve(this.rbuf, size))
|
|
||||||
}
|
|
||||||
write(this.bbuf!!)
|
|
||||||
}
|
|
||||||
|
|
||||||
fun putByte(v: Byte) {
|
|
||||||
this.reserve(1) { bbuf ->
|
|
||||||
bbuf.put(v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fun putShort(v: Short) {
|
|
||||||
this.reserve(2) { bbuf ->
|
|
||||||
bbuf.putShort(v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fun putInt(v: Int) {
|
|
||||||
this.reserve(4) { bbuf ->
|
|
||||||
bbuf.putInt(v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fun putLong(v: Long) {
|
|
||||||
this.reserve(8) { bbuf ->
|
|
||||||
bbuf.putLong(v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fun putFloat(v: Float) {
|
|
||||||
this.reserve(4) { bbuf ->
|
|
||||||
bbuf.putFloat(v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fun putDouble(v: Double) {
|
|
||||||
this.reserve(8) { bbuf ->
|
|
||||||
bbuf.putDouble(v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fun put(v: ByteArray) {
|
|
||||||
this.reserve(v.size) { bbuf ->
|
|
||||||
bbuf.put(v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Helpers for reading primitive data types from a bytebuffer.
|
|
||||||
|
|
||||||
internal fun<T> liftFromRustBuffer(rbuf: RustBuffer.ByValue, readItem: (ByteBuffer) -> T): T {
|
|
||||||
val buf = rbuf.asByteBuffer()!!
|
|
||||||
try {
|
|
||||||
val item = readItem(buf)
|
|
||||||
if (buf.hasRemaining()) {
|
|
||||||
throw RuntimeException("junk remaining in buffer after lifting, something is very wrong!!")
|
|
||||||
}
|
|
||||||
return item
|
|
||||||
} finally {
|
|
||||||
RustBuffer.free(rbuf)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
internal fun<T> lowerIntoRustBuffer(v: T, writeItem: (T, RustBufferBuilder) -> Unit): RustBuffer.ByValue {
|
|
||||||
// TODO: maybe we can calculate some sort of initial size hint?
|
|
||||||
val buf = RustBufferBuilder()
|
|
||||||
try {
|
|
||||||
writeItem(v, buf)
|
|
||||||
return buf.finalize()
|
|
||||||
} catch (e: Throwable) {
|
|
||||||
buf.discard()
|
|
||||||
throw e
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// For every type used in the interface, we provide helper methods for conveniently
|
|
||||||
// lifting and lowering that type from C-compatible data, and for reading and writing
|
|
||||||
// values of that type in a buffer.
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
internal fun String.Companion.lift(rbuf: RustBuffer.ByValue): String {
|
|
||||||
try {
|
|
||||||
val byteArr = ByteArray(rbuf.len)
|
|
||||||
rbuf.asByteBuffer()!!.get(byteArr)
|
|
||||||
return byteArr.toString(Charsets.UTF_8)
|
|
||||||
} finally {
|
|
||||||
RustBuffer.free(rbuf)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
internal fun String.Companion.read(buf: ByteBuffer): String {
|
|
||||||
val len = buf.getInt()
|
|
||||||
val byteArr = ByteArray(len)
|
|
||||||
buf.get(byteArr)
|
|
||||||
return byteArr.toString(Charsets.UTF_8)
|
|
||||||
}
|
|
||||||
|
|
||||||
internal fun String.lower(): RustBuffer.ByValue {
|
|
||||||
val byteArr = this.toByteArray(Charsets.UTF_8)
|
|
||||||
// Ideally we'd pass these bytes to `ffi_bytebuffer_from_bytes`, but doing so would require us
|
|
||||||
// to copy them into a JNA `Memory`. So we might as well directly copy them into a `RustBuffer`.
|
|
||||||
val rbuf = RustBuffer.alloc(byteArr.size)
|
|
||||||
rbuf.asByteBuffer()!!.put(byteArr)
|
|
||||||
return rbuf
|
|
||||||
}
|
|
||||||
|
|
||||||
internal fun String.write(buf: RustBufferBuilder) {
|
|
||||||
val byteArr = this.toByteArray(Charsets.UTF_8)
|
|
||||||
buf.putInt(byteArr.size)
|
|
||||||
buf.put(byteArr)
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
@Synchronized
|
|
||||||
fun findLibraryName(componentName: String): String {
|
|
||||||
val libOverride = System.getProperty("uniffi.component.${componentName}.libraryOverride")
|
|
||||||
if (libOverride != null) {
|
|
||||||
return libOverride
|
|
||||||
}
|
|
||||||
return "uniffi_bdk"
|
|
||||||
}
|
|
||||||
|
|
||||||
inline fun <reified Lib : Library> loadIndirect(
|
|
||||||
componentName: String
|
|
||||||
): Lib {
|
|
||||||
return Native.load<Lib>(findLibraryName(componentName), Lib::class.java)
|
|
||||||
}
|
|
||||||
|
|
||||||
// A JNA Library to expose the extern-C FFI definitions.
|
|
||||||
// This is an implementation detail which will be called internally by the public API.
|
|
||||||
|
|
||||||
internal interface _UniFFILib : Library {
|
|
||||||
companion object {
|
|
||||||
internal val INSTANCE: _UniFFILib by lazy {
|
|
||||||
loadIndirect<_UniFFILib>(componentName = "bdk")
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fun ffi_bdk_ed55_OfflineWallet_object_free(ptr: Pointer,
|
|
||||||
uniffi_out_err: RustCallStatus
|
|
||||||
): Unit
|
|
||||||
|
|
||||||
fun bdk_ed55_OfflineWallet_new(descriptor: RustBuffer.ByValue,
|
|
||||||
uniffi_out_err: RustCallStatus
|
|
||||||
): Pointer
|
|
||||||
|
|
||||||
fun ffi_bdk_ed55_rustbuffer_alloc(size: Int,
|
|
||||||
uniffi_out_err: RustCallStatus
|
|
||||||
): RustBuffer.ByValue
|
|
||||||
|
|
||||||
fun ffi_bdk_ed55_rustbuffer_from_bytes(bytes: ForeignBytes.ByValue,
|
|
||||||
uniffi_out_err: RustCallStatus
|
|
||||||
): RustBuffer.ByValue
|
|
||||||
|
|
||||||
fun ffi_bdk_ed55_rustbuffer_free(buf: RustBuffer.ByValue,
|
|
||||||
uniffi_out_err: RustCallStatus
|
|
||||||
): Unit
|
|
||||||
|
|
||||||
fun ffi_bdk_ed55_rustbuffer_reserve(buf: RustBuffer.ByValue,additional: Int,
|
|
||||||
uniffi_out_err: RustCallStatus
|
|
||||||
): RustBuffer.ByValue
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
// A handful of classes and functions to support the generated data structures.
|
|
||||||
// This would be a good candidate for isolating in its own ffi-support lib.
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// Interface implemented by anything that can contain an object reference.
|
|
||||||
//
|
|
||||||
// Such types expose a `destroy()` method that must be called to cleanly
|
|
||||||
// dispose of the contained objects. Failure to call this method may result
|
|
||||||
// in memory leaks.
|
|
||||||
//
|
|
||||||
// The easiest way to ensure this method is called is to use the `.use`
|
|
||||||
// helper method to execute a block and destroy the object at the end.
|
|
||||||
interface Disposable {
|
|
||||||
fun destroy()
|
|
||||||
}
|
|
||||||
|
|
||||||
inline fun <T : Disposable?, R> T.use(block: (T) -> R) =
|
|
||||||
try {
|
|
||||||
block(this)
|
|
||||||
} finally {
|
|
||||||
try {
|
|
||||||
// N.B. our implementation is on the nullable type `Disposable?`.
|
|
||||||
this?.destroy()
|
|
||||||
} catch (e: Throwable) {
|
|
||||||
// swallow
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// The base class for all UniFFI Object types.
|
|
||||||
//
|
|
||||||
// This class provides core operations for working with the Rust `Arc<T>` pointer to
|
|
||||||
// the live Rust struct on the other side of the FFI.
|
|
||||||
//
|
|
||||||
// There's some subtlety here, because we have to be careful not to operate on a Rust
|
|
||||||
// struct after it has been dropped, and because we must expose a public API for freeing
|
|
||||||
// the Kotlin wrapper object in lieu of reliable finalizers. The core requirements are:
|
|
||||||
//
|
|
||||||
// * Each `FFIObject` instance holds an opaque pointer to the underlying Rust struct.
|
|
||||||
// Method calls need to read this pointer from the object's state and pass it in to
|
|
||||||
// the Rust FFI.
|
|
||||||
//
|
|
||||||
// * When an `FFIObject` is no longer needed, its pointer should be passed to a
|
|
||||||
// special destructor function provided by the Rust FFI, which will drop the
|
|
||||||
// underlying Rust struct.
|
|
||||||
//
|
|
||||||
// * Given an `FFIObject` instance, calling code is expected to call the special
|
|
||||||
// `destroy` method in order to free it after use, either by calling it explicitly
|
|
||||||
// or by using a higher-level helper like the `use` method. Failing to do so will
|
|
||||||
// leak the underlying Rust struct.
|
|
||||||
//
|
|
||||||
// * We can't assume that calling code will do the right thing, and must be prepared
|
|
||||||
// to handle Kotlin method calls executing concurrently with or even after a call to
|
|
||||||
// `destroy`, and to handle multiple (possibly concurrent!) calls to `destroy`.
|
|
||||||
//
|
|
||||||
// * We must never allow Rust code to operate on the underlying Rust struct after
|
|
||||||
// the destructor has been called, and must never call the destructor more than once.
|
|
||||||
// Doing so may trigger memory unsafety.
|
|
||||||
//
|
|
||||||
// If we try to implement this with mutual exclusion on access to the pointer, there is the
|
|
||||||
// possibility of a race between a method call and a concurrent call to `destroy`:
|
|
||||||
//
|
|
||||||
// * Thread A starts a method call, reads the value of the pointer, but is interrupted
|
|
||||||
// before it can pass the pointer over the FFI to Rust.
|
|
||||||
// * Thread B calls `destroy` and frees the underlying Rust struct.
|
|
||||||
// * Thread A resumes, passing the already-read pointer value to Rust and triggering
|
|
||||||
// a use-after-free.
|
|
||||||
//
|
|
||||||
// One possible solution would be to use a `ReadWriteLock`, with each method call taking
|
|
||||||
// a read lock (and thus allowed to run concurrently) and the special `destroy` method
|
|
||||||
// taking a write lock (and thus blocking on live method calls). However, we aim not to
|
|
||||||
// generate methods with any hidden blocking semantics, and a `destroy` method that might
|
|
||||||
// block if called incorrectly seems to meet that bar.
|
|
||||||
//
|
|
||||||
// So, we achieve our goals by giving each `FFIObject` an associated `AtomicLong` counter to track
|
|
||||||
// the number of in-flight method calls, and an `AtomicBoolean` flag to indicate whether `destroy`
|
|
||||||
// has been called. These are updated according to the following rules:
|
|
||||||
//
|
|
||||||
// * The initial value of the counter is 1, indicating a live object with no in-flight calls.
|
|
||||||
// The initial value for the flag is false.
|
|
||||||
//
|
|
||||||
// * At the start of each method call, we atomically check the counter.
|
|
||||||
// If it is 0 then the underlying Rust struct has already been destroyed and the call is aborted.
|
|
||||||
// If it is nonzero them we atomically increment it by 1 and proceed with the method call.
|
|
||||||
//
|
|
||||||
// * At the end of each method call, we atomically decrement and check the counter.
|
|
||||||
// If it has reached zero then we destroy the underlying Rust struct.
|
|
||||||
//
|
|
||||||
// * When `destroy` is called, we atomically flip the flag from false to true.
|
|
||||||
// If the flag was already true we silently fail.
|
|
||||||
// Otherwise we atomically decrement and check the counter.
|
|
||||||
// If it has reached zero then we destroy the underlying Rust struct.
|
|
||||||
//
|
|
||||||
// Astute readers may observe that this all sounds very similar to the way that Rust's `Arc<T>` works,
|
|
||||||
// and indeed it is, with the addition of a flag to guard against multiple calls to `destroy`.
|
|
||||||
//
|
|
||||||
// The overall effect is that the underlying Rust struct is destroyed only when `destroy` has been
|
|
||||||
// called *and* all in-flight method calls have completed, avoiding violating any of the expectations
|
|
||||||
// of the underlying Rust code.
|
|
||||||
//
|
|
||||||
// In the future we may be able to replace some of this with automatic finalization logic, such as using
|
|
||||||
// the new "Cleaner" functionaility in Java 9. The above scheme has been designed to work even if `destroy` is
|
|
||||||
// invoked by garbage-collection machinery rather than by calling code (which by the way, it's apparently also
|
|
||||||
// possible for the JVM to finalize an object while there is an in-flight call to one of its methods [1],
|
|
||||||
// so there would still be some complexity here).
|
|
||||||
//
|
|
||||||
// Sigh...all of this for want of a robust finalization mechanism.
|
|
||||||
//
|
|
||||||
// [1] https://stackoverflow.com/questions/24376768/can-java-finalize-an-object-when-it-is-still-in-scope/24380219
|
|
||||||
//
|
|
||||||
abstract class FFIObject(
|
|
||||||
protected val pointer: Pointer
|
|
||||||
): Disposable, AutoCloseable {
|
|
||||||
|
|
||||||
val wasDestroyed = AtomicBoolean(false)
|
|
||||||
val callCounter = AtomicLong(1)
|
|
||||||
|
|
||||||
open protected fun freeRustArcPtr() {
|
|
||||||
// To be overridden in subclasses.
|
|
||||||
}
|
|
||||||
|
|
||||||
override fun destroy() {
|
|
||||||
// Only allow a single call to this method.
|
|
||||||
// TODO: maybe we should log a warning if called more than once?
|
|
||||||
if (this.wasDestroyed.compareAndSet(false, true)) {
|
|
||||||
// This decrement always matches the initial count of 1 given at creation time.
|
|
||||||
if (this.callCounter.decrementAndGet() == 0L) {
|
|
||||||
this.freeRustArcPtr()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@Synchronized
|
|
||||||
override fun close() {
|
|
||||||
this.destroy()
|
|
||||||
}
|
|
||||||
|
|
||||||
internal inline fun <R> callWithPointer(block: (ptr: Pointer) -> R): R {
|
|
||||||
// Check and increment the call counter, to keep the object alive.
|
|
||||||
// This needs a compare-and-set retry loop in case of concurrent updates.
|
|
||||||
do {
|
|
||||||
val c = this.callCounter.get()
|
|
||||||
if (c == 0L) {
|
|
||||||
throw IllegalStateException("${this.javaClass.simpleName} object has already been destroyed")
|
|
||||||
}
|
|
||||||
if (c == Long.MAX_VALUE) {
|
|
||||||
throw IllegalStateException("${this.javaClass.simpleName} call counter would overflow")
|
|
||||||
}
|
|
||||||
} while (! this.callCounter.compareAndSet(c, c + 1L))
|
|
||||||
// Now we can safely do the method call without the pointer being freed concurrently.
|
|
||||||
try {
|
|
||||||
return block(this.pointer)
|
|
||||||
} finally {
|
|
||||||
// This decrement aways matches the increment we performed above.
|
|
||||||
if (this.callCounter.decrementAndGet() == 0L) {
|
|
||||||
this.freeRustArcPtr()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// Public interface members begin here.
|
|
||||||
// Public facing enums
|
|
||||||
// Error definitions
|
|
||||||
@Structure.FieldOrder("code", "error_buf")
|
|
||||||
internal open class RustCallStatus : Structure() {
|
|
||||||
@JvmField var code: Int = 0
|
|
||||||
@JvmField var error_buf: RustBuffer.ByValue = RustBuffer.ByValue()
|
|
||||||
|
|
||||||
fun isSuccess(): Boolean {
|
|
||||||
return code == 0
|
|
||||||
}
|
|
||||||
|
|
||||||
fun isError(): Boolean {
|
|
||||||
return code == 1
|
|
||||||
}
|
|
||||||
|
|
||||||
fun isPanic(): Boolean {
|
|
||||||
return code == 2
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
class InternalException(message: String) : Exception(message)
|
|
||||||
|
|
||||||
// Each top-level error class has a companion object that can lift the error from the call status's rust buffer
|
|
||||||
interface CallStatusErrorHandler<E> {
|
|
||||||
fun lift(error_buf: RustBuffer.ByValue): E;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Helpers for calling Rust
|
|
||||||
// In practice we usually need to be synchronized to call this safely, so it doesn't
|
|
||||||
// synchronize itself
|
|
||||||
|
|
||||||
// Call a rust function that returns a Result<>. Pass in the Error class companion that corresponds to the Err
|
|
||||||
private inline fun <U, E: Exception> rustCallWithError(errorHandler: CallStatusErrorHandler<E>, callback: (RustCallStatus) -> U): U {
|
|
||||||
var status = RustCallStatus();
|
|
||||||
val return_value = callback(status)
|
|
||||||
if (status.isSuccess()) {
|
|
||||||
return return_value
|
|
||||||
} else if (status.isError()) {
|
|
||||||
throw errorHandler.lift(status.error_buf)
|
|
||||||
} else if (status.isPanic()) {
|
|
||||||
// when the rust code sees a panic, it tries to construct a rustbuffer
|
|
||||||
// with the message. but if that code panics, then it just sends back
|
|
||||||
// an empty buffer.
|
|
||||||
if (status.error_buf.len > 0) {
|
|
||||||
throw InternalException(String.lift(status.error_buf))
|
|
||||||
} else {
|
|
||||||
throw InternalException("Rust panic")
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
throw InternalException("Unknown rust call status: $status.code")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// CallStatusErrorHandler implementation for times when we don't expect a CALL_ERROR
|
|
||||||
object NullCallStatusErrorHandler: CallStatusErrorHandler<InternalException> {
|
|
||||||
override fun lift(error_buf: RustBuffer.ByValue): InternalException {
|
|
||||||
RustBuffer.free(error_buf)
|
|
||||||
return InternalException("Unexpected CALL_ERROR")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Call a rust function that returns a plain value
|
|
||||||
private inline fun <U> rustCall(callback: (RustCallStatus) -> U): U {
|
|
||||||
return rustCallWithError(NullCallStatusErrorHandler, callback);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Public facing records
|
|
||||||
|
|
||||||
// Namespace functions
|
|
||||||
|
|
||||||
|
|
||||||
// Objects
|
|
||||||
|
|
||||||
|
|
||||||
public interface OfflineWalletInterface {
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
class OfflineWallet(
|
|
||||||
pointer: Pointer
|
|
||||||
) : FFIObject(pointer), OfflineWalletInterface {
|
|
||||||
constructor(descriptor: String ) :
|
|
||||||
this(
|
|
||||||
rustCall() { status ->
|
|
||||||
_UniFFILib.INSTANCE.bdk_ed55_OfflineWallet_new(descriptor.lower() ,status)
|
|
||||||
})
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Disconnect the object from the underlying Rust object.
|
|
||||||
*
|
|
||||||
* It can be called more than once, but once called, interacting with the object
|
|
||||||
* causes an `IllegalStateException`.
|
|
||||||
*
|
|
||||||
* Clients **must** call this method once done with the object, or cause a memory leak.
|
|
||||||
*/
|
|
||||||
override protected fun freeRustArcPtr() {
|
|
||||||
rustCall() { status ->
|
|
||||||
_UniFFILib.INSTANCE.ffi_bdk_ed55_OfflineWallet_object_free(this.pointer, status)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
internal fun lower(): Pointer = callWithPointer { it }
|
|
||||||
|
|
||||||
internal fun write(buf: RustBufferBuilder) {
|
|
||||||
// The Rust code always expects pointers written as 8 bytes,
|
|
||||||
// and will fail to compile if they don't fit.
|
|
||||||
buf.putLong(Pointer.nativeValue(this.lower()))
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
companion object {
|
|
||||||
internal fun lift(ptr: Pointer): OfflineWallet {
|
|
||||||
return OfflineWallet(ptr)
|
|
||||||
}
|
|
||||||
|
|
||||||
internal fun read(buf: ByteBuffer): OfflineWallet {
|
|
||||||
// The Rust code always writes pointers as 8 bytes, and will
|
|
||||||
// fail to compile if they don't fit.
|
|
||||||
return OfflineWallet.lift(Pointer(buf.getLong()))
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// Callback Interfaces
|
|
||||||
|
|
||||||
|
|
||||||
@ -1,106 +0,0 @@
|
|||||||
use ::safer_ffi::prelude::*;
|
|
||||||
use bdk::blockchain::{AnyBlockchainConfig, ElectrumBlockchainConfig};
|
|
||||||
use safer_ffi::boxed::Box;
|
|
||||||
use safer_ffi::char_p::char_p_ref;
|
|
||||||
|
|
||||||
#[derive_ReprC]
|
|
||||||
#[ReprC::opaque]
|
|
||||||
#[derive(Debug)]
|
|
||||||
pub struct BlockchainConfig {
|
|
||||||
pub raw: AnyBlockchainConfig,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[ffi_export]
|
|
||||||
fn new_electrum_config(
|
|
||||||
url: char_p_ref,
|
|
||||||
socks5: Option<char_p_ref>,
|
|
||||||
retry: i16,
|
|
||||||
timeout: i16,
|
|
||||||
stop_gap: usize,
|
|
||||||
) -> Box<BlockchainConfig> {
|
|
||||||
let url = url.to_string();
|
|
||||||
let socks5 = socks5.map(|s| s.to_string());
|
|
||||||
let retry = short_to_u8(retry);
|
|
||||||
let timeout = short_to_optional_u8(timeout);
|
|
||||||
|
|
||||||
let electrum_config = AnyBlockchainConfig::Electrum(ElectrumBlockchainConfig {
|
|
||||||
url,
|
|
||||||
socks5,
|
|
||||||
retry,
|
|
||||||
timeout,
|
|
||||||
stop_gap,
|
|
||||||
});
|
|
||||||
Box::new(BlockchainConfig {
|
|
||||||
raw: electrum_config,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
#[ffi_export]
|
|
||||||
fn free_blockchain_config(blockchain_config: Box<BlockchainConfig>) {
|
|
||||||
drop(blockchain_config);
|
|
||||||
}
|
|
||||||
|
|
||||||
// TODO compact_filter rocksdb not compiling on android, switch to sqlite?
|
|
||||||
//#[derive_ReprC]
|
|
||||||
//#[repr(C)]
|
|
||||||
//#[derive(Debug)]
|
|
||||||
//pub struct BitcoinPeerConfig {
|
|
||||||
// pub address: char_p_boxed,
|
|
||||||
// pub socks5: Option<char_p_boxed>,
|
|
||||||
// pub socks5_credentials: Option<Box<Tuple2<char_p_boxed, char_p_boxed>>>,
|
|
||||||
//}
|
|
||||||
//
|
|
||||||
//impl From<&BitcoinPeerConfig> for BdkBitcoinPeerConfig {
|
|
||||||
// fn from(config: &BitcoinPeerConfig) -> Self {
|
|
||||||
// let address = config.address.to_string();
|
|
||||||
// let socks5 = config.socks5.as_ref().map(|p| p.to_string());
|
|
||||||
// let socks5_credentials = config
|
|
||||||
// .socks5_credentials.as_ref()
|
|
||||||
// .map(|c| (c._0.to_string(), c._1.to_string()));
|
|
||||||
//
|
|
||||||
// BdkBitcoinPeerConfig {
|
|
||||||
// address,
|
|
||||||
// socks5: socks5,
|
|
||||||
// socks5_credentials: socks5_credentials,
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
//}
|
|
||||||
//
|
|
||||||
//
|
|
||||||
//#[ffi_export]
|
|
||||||
//fn new_compact_filters_config<'lt>(
|
|
||||||
// peers: c_slice::Ref<'lt, BitcoinPeerConfig>,
|
|
||||||
// network: char_p_ref,
|
|
||||||
// storage_dir: char_p_ref,
|
|
||||||
// skip_blocks: usize,
|
|
||||||
//) -> Box<BlockchainConfig> {
|
|
||||||
// let peers = peers.iter().map(|p| p.into()).collect();
|
|
||||||
// let network = Network::from_str(network.to_str()).unwrap();
|
|
||||||
// let storage_dir = storage_dir.to_string();
|
|
||||||
// let skip_blocks = Some(skip_blocks);
|
|
||||||
// let cf_config = AnyBlockchainConfig::CompactFilters(CompactFiltersBlockchainConfig {
|
|
||||||
// peers,
|
|
||||||
// network,
|
|
||||||
// storage_dir,
|
|
||||||
// skip_blocks,
|
|
||||||
// });
|
|
||||||
// Box::new(BlockchainConfig { raw: cf_config })
|
|
||||||
//}
|
|
||||||
|
|
||||||
// utility functions
|
|
||||||
|
|
||||||
fn short_to_optional_u8(short: i16) -> Option<u8> {
|
|
||||||
if short < 0 {
|
|
||||||
None
|
|
||||||
} else {
|
|
||||||
Some(short_to_u8(short))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn short_to_u8(short: i16) -> u8 {
|
|
||||||
if short < 0 {
|
|
||||||
u8::MIN
|
|
||||||
} else {
|
|
||||||
u8::try_from(short).unwrap_or(u8::MAX)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,32 +0,0 @@
|
|||||||
use ::safer_ffi::prelude::*;
|
|
||||||
use bdk::database::any::SledDbConfiguration;
|
|
||||||
use bdk::database::AnyDatabaseConfig;
|
|
||||||
use safer_ffi::boxed::Box;
|
|
||||||
use safer_ffi::char_p::char_p_ref;
|
|
||||||
|
|
||||||
#[derive_ReprC]
|
|
||||||
#[ReprC::opaque]
|
|
||||||
#[derive(Debug)]
|
|
||||||
pub struct DatabaseConfig {
|
|
||||||
pub raw: AnyDatabaseConfig,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[ffi_export]
|
|
||||||
fn new_memory_config() -> Box<DatabaseConfig> {
|
|
||||||
let memory_config = AnyDatabaseConfig::Memory(());
|
|
||||||
Box::new(DatabaseConfig { raw: memory_config })
|
|
||||||
}
|
|
||||||
|
|
||||||
#[ffi_export]
|
|
||||||
fn new_sled_config(path: char_p_ref, tree_name: char_p_ref) -> Box<DatabaseConfig> {
|
|
||||||
let path = path.to_string();
|
|
||||||
let tree_name = tree_name.to_string();
|
|
||||||
|
|
||||||
let sled_config = AnyDatabaseConfig::Sled(SledDbConfiguration { path, tree_name });
|
|
||||||
Box::new(DatabaseConfig { raw: sled_config })
|
|
||||||
}
|
|
||||||
|
|
||||||
#[ffi_export]
|
|
||||||
fn free_database_config(database_config: Box<DatabaseConfig>) {
|
|
||||||
drop(database_config);
|
|
||||||
}
|
|
||||||
@ -1,175 +0,0 @@
|
|||||||
use std::convert::TryFrom;
|
|
||||||
use std::ffi::CString;
|
|
||||||
|
|
||||||
use ::safer_ffi::prelude::*;
|
|
||||||
use bdk::blockchain::{log_progress, AnyBlockchain, AnyBlockchainConfig, ConfigurableBlockchain};
|
|
||||||
use bdk::database::{AnyDatabase, AnyDatabaseConfig, ConfigurableDatabase};
|
|
||||||
use bdk::wallet::AddressIndex::New;
|
|
||||||
use bdk::{Error, Wallet};
|
|
||||||
use safer_ffi::boxed::Box;
|
|
||||||
use safer_ffi::char_p::{char_p_boxed, char_p_ref};
|
|
||||||
|
|
||||||
use blockchain::BlockchainConfig;
|
|
||||||
use database::DatabaseConfig;
|
|
||||||
|
|
||||||
use crate::error::FfiError;
|
|
||||||
use crate::types::{FfiResult, FfiResultVoid};
|
|
||||||
use crate::wallet::transaction::{LocalUtxo, TransactionDetails};
|
|
||||||
use bdk::bitcoin::Network;
|
|
||||||
use std::str::FromStr;
|
|
||||||
|
|
||||||
mod blockchain;
|
|
||||||
mod database;
|
|
||||||
mod transaction;
|
|
||||||
|
|
||||||
// create a new wallet
|
|
||||||
|
|
||||||
#[derive_ReprC]
|
|
||||||
#[ReprC::opaque]
|
|
||||||
pub struct OpaqueWallet {
|
|
||||||
raw: Wallet<AnyBlockchain, AnyDatabase>,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[ffi_export]
|
|
||||||
fn new_wallet_result(
|
|
||||||
descriptor: char_p_ref,
|
|
||||||
change_descriptor: Option<char_p_ref>,
|
|
||||||
network: char_p_ref,
|
|
||||||
blockchain_config: &BlockchainConfig,
|
|
||||||
database_config: &DatabaseConfig,
|
|
||||||
) -> FfiResult<Option<Box<OpaqueWallet>>> {
|
|
||||||
let descriptor = descriptor.to_string();
|
|
||||||
let change_descriptor = change_descriptor.map(|s| s.to_string());
|
|
||||||
let net = Network::from_str(network.to_str()).expect("Network name");
|
|
||||||
let bc_config = &blockchain_config.raw;
|
|
||||||
let db_config = &database_config.raw;
|
|
||||||
let wallet_result = new_wallet(descriptor, change_descriptor, net, bc_config, db_config);
|
|
||||||
|
|
||||||
match wallet_result {
|
|
||||||
Ok(w) => FfiResult {
|
|
||||||
ok: Some(Box::new(OpaqueWallet { raw: w })),
|
|
||||||
err: FfiError::None,
|
|
||||||
},
|
|
||||||
Err(e) => FfiResult {
|
|
||||||
ok: None,
|
|
||||||
err: FfiError::from(&e),
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn new_wallet(
|
|
||||||
descriptor: String,
|
|
||||||
change_descriptor: Option<String>,
|
|
||||||
network: Network,
|
|
||||||
blockchain_config: &AnyBlockchainConfig,
|
|
||||||
database_config: &AnyDatabaseConfig,
|
|
||||||
) -> Result<Wallet<AnyBlockchain, AnyDatabase>, Error> {
|
|
||||||
let client = AnyBlockchain::from_config(blockchain_config)?;
|
|
||||||
let database = AnyDatabase::from_config(database_config)?;
|
|
||||||
|
|
||||||
let descriptor: &str = descriptor.as_str();
|
|
||||||
let change_descriptor: Option<&str> = change_descriptor.as_deref();
|
|
||||||
|
|
||||||
Wallet::new(descriptor, change_descriptor, network, database, client)
|
|
||||||
}
|
|
||||||
|
|
||||||
#[ffi_export]
|
|
||||||
fn free_wallet_result(wallet_result: FfiResult<Option<Box<OpaqueWallet>>>) {
|
|
||||||
drop(wallet_result);
|
|
||||||
}
|
|
||||||
|
|
||||||
// wallet operations
|
|
||||||
|
|
||||||
#[ffi_export]
|
|
||||||
fn sync_wallet(opaque_wallet: &OpaqueWallet) -> FfiResultVoid {
|
|
||||||
let int_result = opaque_wallet.raw.sync(log_progress(), Some(100));
|
|
||||||
match int_result {
|
|
||||||
Ok(_v) => FfiResultVoid {
|
|
||||||
err: FfiError::None,
|
|
||||||
},
|
|
||||||
Err(e) => FfiResultVoid {
|
|
||||||
err: FfiError::from(&e),
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[ffi_export]
|
|
||||||
fn new_address(opaque_wallet: &OpaqueWallet) -> FfiResult<char_p_boxed> {
|
|
||||||
let new_address = opaque_wallet.raw.get_address(New);
|
|
||||||
let string_result = new_address.map(|a| a.to_string());
|
|
||||||
match string_result {
|
|
||||||
Ok(a) => FfiResult {
|
|
||||||
ok: char_p_boxed::try_from(a).unwrap(),
|
|
||||||
err: FfiError::None,
|
|
||||||
},
|
|
||||||
Err(e) => FfiResult {
|
|
||||||
ok: char_p_boxed::from(CString::default()),
|
|
||||||
err: FfiError::from(&e),
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[ffi_export]
|
|
||||||
fn list_unspent(opaque_wallet: &OpaqueWallet) -> FfiResult<repr_c::Vec<LocalUtxo>> {
|
|
||||||
let unspent_result = opaque_wallet.raw.list_unspent();
|
|
||||||
|
|
||||||
match unspent_result {
|
|
||||||
Ok(v) => FfiResult {
|
|
||||||
ok: {
|
|
||||||
let ve: Vec<LocalUtxo> = v.iter().map(|lu| LocalUtxo::from(lu)).collect();
|
|
||||||
repr_c::Vec::from(ve)
|
|
||||||
},
|
|
||||||
err: FfiError::None,
|
|
||||||
},
|
|
||||||
Err(e) => FfiResult {
|
|
||||||
ok: repr_c::Vec::EMPTY,
|
|
||||||
err: FfiError::from(&e),
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[ffi_export]
|
|
||||||
fn free_veclocalutxo_result(unspent_result: FfiResult<repr_c::Vec<LocalUtxo>>) {
|
|
||||||
drop(unspent_result)
|
|
||||||
}
|
|
||||||
|
|
||||||
#[ffi_export]
|
|
||||||
fn balance(opaque_wallet: &OpaqueWallet) -> FfiResult<u64> {
|
|
||||||
let balance_result = opaque_wallet.raw.get_balance();
|
|
||||||
|
|
||||||
match balance_result {
|
|
||||||
Ok(b) => FfiResult {
|
|
||||||
ok: b,
|
|
||||||
err: FfiError::None,
|
|
||||||
},
|
|
||||||
Err(e) => FfiResult {
|
|
||||||
ok: u64::MIN,
|
|
||||||
err: FfiError::from(&e),
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[ffi_export]
|
|
||||||
fn list_transactions(opaque_wallet: &OpaqueWallet) -> FfiResult<repr_c::Vec<TransactionDetails>> {
|
|
||||||
let transactions_result = opaque_wallet.raw.list_transactions(false);
|
|
||||||
|
|
||||||
match transactions_result {
|
|
||||||
Ok(v) => FfiResult {
|
|
||||||
ok: {
|
|
||||||
let ve: Vec<TransactionDetails> =
|
|
||||||
v.iter().map(|t| TransactionDetails::from(t)).collect();
|
|
||||||
repr_c::Vec::from(ve)
|
|
||||||
},
|
|
||||||
err: FfiError::None,
|
|
||||||
},
|
|
||||||
Err(e) => FfiResult {
|
|
||||||
ok: repr_c::Vec::EMPTY,
|
|
||||||
err: FfiError::from(&e),
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[ffi_export]
|
|
||||||
fn free_vectxdetails_result(txdetails_result: FfiResult<repr_c::Vec<TransactionDetails>>) {
|
|
||||||
drop(txdetails_result)
|
|
||||||
}
|
|
||||||
@ -1,124 +0,0 @@
|
|||||||
use std::convert::TryFrom;
|
|
||||||
|
|
||||||
use ::safer_ffi::prelude::*;
|
|
||||||
use safer_ffi::char_p::char_p_boxed;
|
|
||||||
|
|
||||||
// Non-opaque returned values
|
|
||||||
|
|
||||||
#[derive_ReprC]
|
|
||||||
#[repr(C)]
|
|
||||||
#[derive(Debug, Clone)]
|
|
||||||
pub struct TransactionDetails {
|
|
||||||
// TODO Optional transaction
|
|
||||||
// pub transaction: Option<Transaction>,
|
|
||||||
/// Transaction id
|
|
||||||
pub txid: char_p_boxed,
|
|
||||||
/// Received value (sats)
|
|
||||||
pub received: u64,
|
|
||||||
/// Sent value (sats)
|
|
||||||
pub sent: u64,
|
|
||||||
/// Fee value (sats) if known, -1 if unknown, based on backend
|
|
||||||
pub fee: i64,
|
|
||||||
/// true if confirmed
|
|
||||||
pub is_confirmed: bool,
|
|
||||||
/// Confirmed in block height
|
|
||||||
pub confirmation_time: ConfirmationTime,
|
|
||||||
/// Whether the tx has been verified against the consensus rules
|
|
||||||
pub verified: bool,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive_ReprC]
|
|
||||||
#[repr(C)]
|
|
||||||
#[derive(Debug, Clone)]
|
|
||||||
pub struct ConfirmationTime {
|
|
||||||
/// confirmation block height, 0 if is_confirmed is false
|
|
||||||
pub height: u32,
|
|
||||||
/// confirmation block timestamp, 0 if is_confirmed is false
|
|
||||||
pub timestamp: u64,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<&bdk::TransactionDetails> for TransactionDetails {
|
|
||||||
fn from(op: &bdk::TransactionDetails) -> Self {
|
|
||||||
let fee = op.fee.map(|f| i64::try_from(f).unwrap()).unwrap_or(-1);
|
|
||||||
let confirmation_time = op
|
|
||||||
.confirmation_time
|
|
||||||
.as_ref()
|
|
||||||
.map(|c| ConfirmationTime {
|
|
||||||
height: c.height,
|
|
||||||
timestamp: c.timestamp,
|
|
||||||
})
|
|
||||||
.unwrap_or(ConfirmationTime {
|
|
||||||
height: 0,
|
|
||||||
timestamp: 0,
|
|
||||||
});
|
|
||||||
TransactionDetails {
|
|
||||||
txid: char_p_boxed::try_from(op.txid.to_string()).unwrap(),
|
|
||||||
received: op.received,
|
|
||||||
sent: op.sent,
|
|
||||||
fee,
|
|
||||||
is_confirmed: op.confirmation_time.is_some(),
|
|
||||||
confirmation_time,
|
|
||||||
verified: op.verified,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive_ReprC]
|
|
||||||
#[repr(C)]
|
|
||||||
#[derive(Debug, Clone)]
|
|
||||||
pub struct OutPoint {
|
|
||||||
/// The referenced transaction's txid, as hex string
|
|
||||||
pub txid: char_p_boxed,
|
|
||||||
/// The index of the referenced output in its transaction's vout
|
|
||||||
pub vout: u32,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<&bdk::bitcoin::OutPoint> for OutPoint {
|
|
||||||
fn from(op: &bdk::bitcoin::OutPoint) -> Self {
|
|
||||||
OutPoint {
|
|
||||||
txid: char_p_boxed::try_from(op.txid.to_string()).unwrap(),
|
|
||||||
vout: op.vout,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive_ReprC]
|
|
||||||
#[repr(C)]
|
|
||||||
#[derive(Debug, Clone)]
|
|
||||||
pub struct TxOut {
|
|
||||||
/// The value of the output, in satoshis
|
|
||||||
pub value: u64,
|
|
||||||
/// The script which must satisfy for the output to be spent, as hex string
|
|
||||||
pub script_pubkey: char_p_boxed,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<&bdk::bitcoin::TxOut> for TxOut {
|
|
||||||
fn from(to: &bdk::bitcoin::TxOut) -> Self {
|
|
||||||
TxOut {
|
|
||||||
value: to.value,
|
|
||||||
script_pubkey: char_p_boxed::try_from(to.script_pubkey.to_string()).unwrap(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive_ReprC]
|
|
||||||
#[repr(C)]
|
|
||||||
#[derive(Debug, Clone)]
|
|
||||||
pub struct LocalUtxo {
|
|
||||||
/// Reference to a transaction output
|
|
||||||
pub outpoint: OutPoint,
|
|
||||||
/// Transaction output
|
|
||||||
pub txout: TxOut,
|
|
||||||
/// Type of keychain, as short 0 for "external" or 1 for "internal"
|
|
||||||
pub keychain: u16,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<&bdk::LocalUtxo> for LocalUtxo {
|
|
||||||
fn from(lu: &bdk::LocalUtxo) -> Self {
|
|
||||||
LocalUtxo {
|
|
||||||
outpoint: OutPoint::from(&lu.outpoint),
|
|
||||||
txout: TxOut::from(&lu.txout),
|
|
||||||
keychain: lu.keychain as u16,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Loading…
x
Reference in New Issue
Block a user