[TS] Create .d.mts files by default

[TS] Fix HTML test runner to properly await and fully check result

Merge pull request #78 from arik-so/typescript_fixes

Make npm publication generate node-compatible modules.

Include type declaration files and remove typically unnecessary dependencies.

Update files to include *.mjs files and remove npmignore.

Update .gitignore

Update .npmignore

Update .gitignore

Make publication generate node-compatible modules.

Merge pull request #74 from TheBlueMatt/2022-01-ts-hu-files

[TypeScript] Make Basic "Human" Object Construction Work

Update auto-generated TypeScript Bindings

Update auto-generated Java bindings (all functionally equivalent)

Split Java CI runs into tests and binary determinism checks

[TS] Add package.json for public release

[TS] Update README to describe TS as "early alpha" 🚀

[TS] Change paths to liblightningjs.wasm to be in ts/

[TS] Add a basic functional tests of human types

[TS] Drop InternalUtils as they are now called via bindings.

[TS] Swap BigInt (the class/constructor) for bigint (the primitive)

Support mapping primitive arrays as non-arrays (eg numbers)

TypeScript can't pass an array through to C, so we have to pass a
pointer to a constructed array. This adds support in the relevant
type-conversion logic to enable this (and uses it in TS).

Ensure `TypeInfo` always has `subty` set if its an array

Make String types language-specific and fix TS string conversion

Skip reference-holding in static methods in a (kinda-)cleaner way

[TS] Clean up wasm environment exports

[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.