clean up bindings trait output

use templates for human type conversions

fix argument/type order in interface method override declaration

inch towards more map_trait cleanup for Typescript

add typescript tuple generics

expand c type conversions to other integer array types

initiate language-dependent type mappings from C

override CommonBase file, and make private constructor work for mapped traits

bindings updates

[double-free, with XXX] More conv for traits

auto-generated bindings updates

Parse complex enum fields prior to per-language logic, drop java-isms in TS

TS bindings

Fix file extension for typescript

Complex enum mappings

Revert "Somewhat redundant changes (new file_ext, arg parse, etc)" - this breaks genbindings.sh

This reverts commit ca0405752b09a0fb820d4be6f1e14a346614f21d.

Somewhat redundant changes (new file_ext, arg parse, etc)

Use file_ext everywhere, common base/header for TS files

Java bindings updates with new generator, with no functional changes

Add TS bindings generation, with per-lang strings in their own file

bindings updates

Walk back some of the clone updates, with comments to fix later

updated bindings

Rewrite clone handling to manually-define them for types, though almost unused

Updated bindings

update to new upstream

Fix write method generation w/ upstream changes

Fix race in tests

Optionally use a ChainMonitor instead of custom Watch in testing

clone traits before passing to jcalls and map to human types

Update Human object test to use SocketDescriptor traits (which worked the first time!)

Fix returning traits in trait calls, move towards clone on return

Stop masking the owned bit on a freshly-cloned object

Map Transactions as byte[] instead of trying to keep a ptr

Rework holds_ref and clone logic somewhat

Fix tests for new API

Properly handle java refs in traits returning traits

Clone before passing to java + new clone upstream

Fix opaque struct ptr ret-conv, used in jcall arg passing

Fix ObjectArray (array-of-arrays) creation

Fix optimized build

Write tuple getters (and test them, exposing memory leak)

Add ability to get serialized transaction bytes

Expand the human object test somewhat

Enable more C build-time warnings

Finish compacting giant type-conversion-strings if tree, updating to new upstream and fixing bugs on the way

Compact giant type-conversion-strings if tree somewhat

Skip fewer fn's, support trait-contained objects

Provide human versions of trait interfaces, with a bunch of fixes to make it work

Sadly gave up trying to get returns to be sane, so now returning an
object from a trait implies that object is now unusable :(.

Rely on pointers even less in HumanObject testing

Expose human functions that use Result objects

Properly free Vec<u8>s after conversion to byte[].

This fixes a memory leak in basically all of the *_write
serialization functions.

Make complex enums more complete, track reference-or-ownership by callsite

Rewrite the world, with several interdependant changes (but several still WIP)

Properly set CVec_u8Z to a byte[] which adds a ton more fn's

Figure out java human types conversion stuff when doing all conv

Split get_inner into get_ok/_err so that we can map the type being returned

Use AutoCloseable for structs named Locked*

explode to constructor args when we cant clone but need to

Drop the _call insertion

Skip methods we can't use anyway

Update to support None

Convert slices - requires some machinery to call Release, but otherwise not bad

Clean up assertions, new Clone impls, ThreeBytes

Expose signatures as byte[], check array lengths in C.

Expose SecretKey as byte[32], expose trait call fns in human structs

Create structs and traits that are (a bit) more human-friendly!

Drop stale jni header files

Agressively clone when passing to rust

New upstream bindings that generate _clone fns

Use weak references to JCalls objects.

This fixes a future usability issue where its easy to create a
lambda which ends up referencing a high-level struct's owning class
and then have the high-level struct hold a global reference to the
lambda, creating a reference cycle that java can't see into.

instead, we require the user hold a reference to the lambda as
long as the parent exists, something which we can automate on the
java bindings end.

Send a payment!

Convert pubkeys to byte arrays, fix assertions, fix result inner fetch, fix java garbage

Fully open and confirm a channel in Java!

A bunch of updates:

 * Switch to passing inner pointers across JNI, not pointers to
   opaque structs. This is more effecient, and the low bit is always
   0.
 * Use bitcoinj to create a block in test and connect it (!)

Intercept all malloc/free, even in Rust!

Map tuples and ThirtyTwoBytes into array.

Move enum mapping to functions

Convert LDKThirtyTwoBytes to byte[32] instead of taking a ptr

More statics and limit exports to Java methods at link

Map Rust enums with inner fields

Cache enum fields

Move enums into their own (non-impl) folder

Add ability to fetch all Vec details in one call.

Go all the way through to channel creation in PeerTest

Add constructors for None opaque struct mappings

Update PeerTest to test most of the new stuff

Make slice-vec-len generic

Macro-ize assert to handle side-effects, fix JavaVM access, util fns

Add missing JCalls parameter conversion

Dont auto-free slices passed to Rust

Reorg a bit and let us call trait methods from Java

Add ability to check if a CResult<> is OK, and get its value pointer

Add ability to get the Java object underlying a _JCalls struct

Fix java short type ID for pointers

Update test for new bindings

Update auto-generated bindings

Update genbindings.sh somewhat for newer upstream

Update to latest upstream bindings

Add new test that builds a ChannelManager