CHECK_ACCESS inner pointers using the new __unmangle_inner_ptr meth

Add Variant-Level docs on complex and unitary enums.

Fixes #60.

Allow users to specify a `UserConfig` when de-ser'ing a ChanManager

Fixes #55.

Hold a reference when we pass Option<Trait> to rust

This resolves a NPE when calling trait methods if the user doesn't
hold their own reference to the underlying trait, which is quite
possible for, eg, the `Filter` object.

We also adapt `HumanObjectPeerTest` to test this with a `Filter`.

Make enum-contains-trait detection more robust

Merge pull request #54 from TheBlueMatt/main

v0.0.103.0

Update Github Actions branch reference to 0.0.103

Add support for InvoicePayer to ChannelManagerConstructor and test

Note that this adds an additional bit of runs in the
HumanObjectPeerTest, bringing leaks for a full run to:
    149 allocations remained for 1157302 bytes.

Update tests for latest upstream API

Leaks in a full test run is now
    89 allocations remained for 1138102 bytes.

Update auto-generated bindings to 0.0.103

Support passing trait instance references from C to Java without clone or double-free

Support nullable for opaque objects as well as traits and some arrays

Treat pointers up to 4096 as null, matching our test values in ldk-c-bindings

Fix race condition in NioPeerHandler on `socket_disconnected`

Use gitweb's snapshots to fetch binaries for comparison, not git

Update auto-generate bindings (incl new RL clone methods)

Don't allocate a buffer to return a reference to a tuple element

If we're returning a reference to an object because we don't have a
clone function available, we'll set the reference flag implying no
free'ing will occur. In that case, we don't need to allocate a
buffer to copy the object's memory, we might as well just return a
pointer to the original.

After this commit, test leaks are:
    73 allocations remained for 1137376 bytes.

Remove (broken) duplicative tuple constructor

Add basic use-after-free checking in limited places.

Sadly this appears to have exposed some missing allocation wraps,
which prevents us from applying this in more locations.

Drop requires_clone ret_conv cloning in complex enums

requires_clone is supposed to be aboug arg_conv, not ret_conv so
its mis-labeled anyway. Somewhat unclear exactly what this was for.

Memory leaks are reduced to:
    169 allocations remained for 1141984 bytes.

Merge pull request #50 from TheBlueMatt/main

v0.0.102.0

Use lld to link on OSX with LLVM 13

Update auto-generated bindings to 0.0.102

Bump OSX clang/LLVM to 13.0.0

Update CI C-Bindings dependency to 0.0.102

Update tests to upstream 0.0.102 API

Merge pull request #49 from TheBlueMatt/main

v0.0.101.3

Update maven to 3.8.3 (since apparently they yank old binaries?!)

Update auto-generated bindings

Update android API version to 24 (Nougat) as we need it for streams

Correctly handle top-bit-set pointers, fixing Android 11

Aggressively avoid object creation during message read handling

[NioPeerHandler] Un-set Read interest when we fail to write fully

...as required by the SocketDescriptor.send_data API docs

Merge pull request #47 from TheBlueMatt/main

v0.0.101.2

Ensure listening sockets are closed to work around OSX breaking

Try new paths for Android NDK library search

I'm not sure where these paths came from to begin with, but [1]
seems to indicate they're wrong, so let's try new ones.

[1] https://developer.android.com/ndk/guides/abis#sa

Drop accidentally checked-in class file and update .gitignore

Update auto-generated bindings

Skip object reference adding when cloning within the FFI on to-Rust object passing

Correct and use ChannelManagerConstructor in HumanObjectPeerTest

When ChannelManagerConstructor support was added, the test loop
bounds were never updated to actually test it. This corrects that
(and a few regressions that snuck in over time).

Memory leaks during tests are now:
    249 allocations remained for 1146062 bytes.

Merge pull request #46 from TheBlueMatt/main

v0.0.101.1

Expand HumanObjectPeerTest to cover get_claimable_balances

Memory leaks during tests are unchanged

Update auto-generated bindings

Memory leaks during tests are now:
    193 allocations remained for 1136846 bytes.

Update batteries to new Tuple-mapping API

Update tests to new Tuple mapping API

Redo tuple mapping to be explicit and not generic

This was suggested by Galder as more Java-y, but also fixes
a number of memory leaks by avoiding the complexity of
always holding references and letting the common code do
more work.

Fix exception catch in native library load failure to catch NPE

Use current HEAD for version in CI instead of previous commit

Move version information out of git into new files

Merge pull request #45 from TheBlueMatt/main

Various fixes + cut 0.0.101

Update auto-generated bindings to 0.0.101

Fix CI failures due to faketime breaking PKI time checks

Update CI branch refernces to 0.0.101

Specify maven plugin versions to avoid inconsistent jars

Expand test coverage in HumanObjectPeerTest to hit new API features

Leak count is now:
    507 allocations remained for 1163454 bytes.

Update batteries and tests to latest upstream API

With the upstream v0.0.101, memory leaks during tests are now:
    411 allocations remained for 1156930 bytes.

Drop reallocarray wrapper, enforcing that we don't need it

Swap java locks to pthread to avoid relying on newer GLIBC versions

Add a build mode for "release optimizations with leaks checks", handle a jar in CI

Implement partial clones when passing complex enums containing traits

Add missing clone when passing a complex enum to Java

Expand the criteria for cloning when passing to Rust

If a method takes an object by ownership, we always need to clone.

Remap non-clonable move-passed optional fn args into Option<&Type>

This may break in the future, so we print a huge warning.

Fix calling Java/TS methods that return strings

Fix conflicting overuse of "ret" as a variable name

Print error information when we fail to load LDK native library

Correctly handle reference tracking for array elements, construct multi-dimentional arrays

Rename ChannelManagerConstructor.ChannelManagerPersister to EventHandler

ChannelManagerPersister is a bit of a misnomer for the struct which
now handles events as well. Thus, we rename it to focus on the
event-handling function here.

Drop dup PeerManager tiemr_tick_occurred calls from NioPeerHandler

We call PeerManager's timer_tick_occurred in the
lightning-background-processor crate, initialized from the
ChannelManagerConstructor. Prior to the use of the
lightning-background-processor we'd needed to call PeerManager's
timer_tick_occurred from NioPeerHandler, but we never dropped it
after the switch. Thus, every ~30 seconds we'll call
PeerManager::timer_tick_occurred twice in a row, disconnecting all
of our peers.

Merge pull request #42 from TheBlueMatt/main

Cut 0.0.100.2 which should be uploadable to Maven Central

Bump version to 0.0.100.2

Skip javadoc generation on OSX since its broken

Update pom.xml to comply with Maven Central requirements

Merge pull request #40 from TheBlueMatt/main

v0.0.100.1

Update autogenerated bindings to new version

Test use of IgnoringMessageHandler with ChannelManagerConstructor

Merge pull request #39 from TheBlueMatt/main

v0.0.100.0

Update auto-generated files

Switch to the 0.0.100 branch on ldk-c-bindings

Update tests to latest upstream master

Correct Rust -> Java method call semantics to avoid double-conversion

Fix cloning trait structs via native clone method

When cloning a trait struct, we need to reference the
already-converted-to-struct value, not the original, integer,
value.

Merge pull request #33 from TheBlueMatt/main

Expose supertrait implemetations to the Java API

Update auto-generated bindings to latest upstream

Note that the inclusion of enum constructor functions fixes #30.

Drop fail-fast in CI to run jobs even after another fails

Move release jar comparisons to run before functional tests in CI

Automatically run diffoscope on changed compressed files in CI

Use the 0.0.99 branch of ldk-c-bindings in CI

Use explicit paths for function arguments in Java

When we have an enum with a variant named the same as a struct we
need to specify a full concrete path when referring to it. The
simplest approach is to just use full concrete paths for all
function arguments, which we do here.

Add an accessor to UInt5 to get the value and correct conversion

Test function returning Option::None returns null to Java

Use new TxOut constructor in tests

Add constructors and expose fields in TxOut

Fixes #34.

Add a simple wrapper for `disconnect_by_node_id` in `NioPeerHandler`

Fixes #36.

Add docs for and mark nullable complex enum fields

Correctly handle passing a null to Rust for an array

Mark function arguments and return values Nullable if relevant

Fixes #35.

Correctly handle null pointers returned from Rust representing None

Fixes the SEGFAULT in #35.

Use findbugs for Nullable annotations instead of jetbrains

Use a full Sign wrapper again in HumanObjectPeerTest

With the new upstream clone API and this, memory leaks during tests are
now:
  418 allocations remained for 1160528 bytes.