Unify tuple and result field getters and push them through map_fn

Update typescript test to latest API

Clean up TS arrays and make TS compile warning-free again

Merge pull request #71 from TheBlueMatt/main

Update readme noting that the bindings are beta, not alpha

Update readme noting that the bindings are beta, not alpha

... and there are no known memory leaks 🎉.

Fixes #70.

Merge pull request #69 from TheBlueMatt/main

v0.0.104.0

Fix Java path setting in OSX builds

Use LC_ALL instead of LANG to correct zip file ordering

Update CI branches to 0.0.104

Update auto-updated Java files

Update tests and batteries for new 0.0.104 API, fix Java 18 build

As of this commit, leaks in the full test suite are:
    20 allocations remained for 1115206 bytes.

Handle the new LDKTwelveBytes instead of LDKTenBytes

Update HumanObjectPeerTest to exercise undefined JVM JIT behavior

Work around Java's insane lack of finalization guarantees

Use the same FindClass argument for Android and regular Java

Its unclear whether the android variant (no L prefix, ; suffix) was
ever tested on normal Java or not, but the existing code generates
a large volumes of warnings on OpenJDK 11 like:

WARNING in native method: JNI FindClass received a bad class descriptor "Lorg/ldk/impl/bindings$LDKEvent$PaymentReceived;".  A correct class descriptor has no leading "L" or trailing ";".  Incorrect descriptors will not be accepted in future releases.

Check exceptions after calling Enum.ordinal() from Rust

This generally shouldn't ever fire, but otherwise Java says, e.g.

WARNING in native method: JNI call made without checking exceptions when required to from CallIntMethod
at org.ldk.impl.bindings.create_invoice_from_channelmanager(Native Method)

throw InvalidSerializedDataException on duplicate ChannelMonitors

Override hashCode and equals for Rust objects that impl the equivalent

Merge pull request #56 from TheBlueMatt/main

v0.0.103.1

Make maven a bit quieter during CI runs

Update to Maven 3.8.4 on OSX CI builds

Update auto-generated bindings

Update tests to new logger API

As of this commit, leaks for a full run are down to:
    17 allocations remained for 1115062 bytes.

Replace unicode … with ... as java complains about non-ASCII docs

Update PeerTest for new trait-object-return call semantics

Clone objects being returned from trait methods before return from Java

When we return an object from a trait method called from Rust, we
often return complex Java "Human" objects. Because the underlying
object is owned by Java, we clone them before passing the objects
back to Rust, if possible. However, the clone call happens after
the Java method returns, at which point Java does not have any
references to the original "Human" object, which upon free will
free the underlying object.

While the time between when the Java method returns and the C FFI
code clones the object is incredibly short, CI did manage to find
the race here in ASAN, where the original object may be freed
before being accessed again for the clone in C.

Here we fix this by simply cloneing the object being returned
directly from Java.

Construct a method to clone returning a pointerand not a human object

Drop unused Vec constructor functions

Map functions on 3-tuples

Use new is_ok functions for Result checks in hand-written code

Update Result mapping to use new `_is_ok` function in the C bindings

Check array lengths before passing them to C

When users pass a static-length array to C we currently CHECK its
length, asserting only if we are built in debug mode. In
production, we happily call JNI's `GetByteArrayRegion` with the
expected length, ignoring any errors. `GetByteArrayRegion`,
however, "THROWS ArrayIndexOutOfBoundsException: if one of the
indexes in the region is not valid.". While its somewhat unclear
what "THROWS" means in the context of a C API, it seems safe to
assume accessing return values after a "THROWS" condition is
undefined. Thus, we should ensure we check array lengths before
calling into C.

We do this here with a simple wrapper function added to
`org.ldk.util.InternalUtils` which checks an array is the correct
length before returning it.

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.