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

Handle size_t's and non-JCalls trait impls

Convert unitary enums to Java enums

Move trait mapping to an fn

Manually track allocations and assert that we don't leak

Rename PeerTest

Add .gitignore

Test current state of things, which actually doesn't crash!

ref-count trait objects to avoid double-free, probably will need to do this everywhere

Convert String (tested from Java!)

Add debug info to liblightningjni.so

Update linking for address sanitizer

Clean up and calculate java method signatures

A bit less logic in map_type

Run conversions on JNI -> Java calls, though need to fill them out

Return, instead of writing, form map_type

Simplify type checking a bit

Support u16s

Compiles with fn calls, even if the call types are bogus

Handle trait return values

Pull out type mapping

Starting to look like something that might work...

New genbindings

Also output a C wrapper that correctly wraps all the JNI functions

Initial bindings header generation demo

Initial Dummy Checkin