[TS] Configure memory setup in linker to not insta-OOM

[TS] Rewrite complex enum creation

We cannot create bindings objects from C in TS, so instead have to
query for individual fields on construction.

[TS] Use export_/import_name to filter exposed symbols

[TS] Correct pointer arithmetic on array construction

[TS] Correctly pass u64s from TS to C, using BigInts

Fix LDKRecoverableSignature variable parsing

Use uintptr_t for the return value of `clone_ptr` to match reality

[TS] Implement Rust -> TS calls and TS Trait instance construction

[TS] Make compiler checks a bit more aggressive, fix indentation

[TS] Fix indentation of bindings.mts somewhat

Fix double free introduced in 9b9e4369d34e24a9dc7f3f1494865a026ca4

This requires correctly setting `holds_ref` as well as handling
`holds_ref` on pointed-to objects in the general-case ret_conv in
`gen_type_mapping.py`.

Merge pull request #73 from TheBlueMatt/main

Make all TypeScript "Human" mappings compile

Update auto-generated TypeScript files

Add a warning for Locked human objects as they are not usable yet

Update tests to test human structs from TypeScript

Make array human construction language-specific

[TS] Correct syntax in human interface files

[TS] Drop references to `this` in static `UtilMethods` functions

Make TxOut language-specific, fix typescript UtilMethods compilation

[TS] Fix syntax errors in human trait definitions

Make array range iteration language-specific

Make human -> C array mapping language-specific

Use wasm's default memory instead of creating/accessing an (unused) one

Make struct pointer loading language-specific and reliable for TS

Make Result mapping language-specific and implement it for TS

Add InternalUtils for array length checking to match Java

[TS] Resolve locally-defined structs in other structs, create index.mts

Make the call for `ptrs_to.add()` swappable per language

[TS] Fix finalization syntax, drop "default" on class exports, minor tweaks

Make variable declaration statements language-specific

[TS] Minor syntax fixes in human struct files, mostly complex enums

Pass output directory throuh to consts and call a cleanup function

Merge pull request #72 from TheBlueMatt/main

Get TypeScript compiling warning-free and properly test wasm loading+calling in CI

Update auto-generated mts files (without structs)

Make genbindings.sh only build one of java/wasm, test wasm in CI

Drop ts/util* which are no longer used/generated

Switch to .mts files and build typescript bindings in genbindings.sh

Fix method reference errors and make bindings.ts generation work again

Fix syntax errors in bindings.ts in option handling

Update tests and batteries to new result API

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?!)