[TS] Fix Some array leaks, mark others, treat < 10 leaks as "okay"

[TS] Empty environment variables as WASI's environ fetch leaks memory

[TS] Use -O1 on debug builds as otherwise they can be unusable slow

[TS] Free native -> human arrays after we're done converting

[TS] Wrap `aligned_alloc` as well as other malloc's.

[TS] Debug allocations somewhat further, incl prints in test.

[TS] Move C header code to next to code that uses it in constr

[TS] Fix Debug builds by removing ((destructor)) attributes

[TS] Remove race-y test for malloc-free-malloc re-using memory

[TS] Swap Os for Oz because its a minor change and a minor win

[TS] Make bindings.mts export nothing, fix some indentation

[TS] Set LDK_GARBAGECOLLECTED_GIT_OVERRIDE so that versions work

[TS] Add bindings-binary-version-check to initializeWasm

[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