explode to constructor args when we cant clone but need to

[ldk-java] / genbindings.py

diff --git a/genbindings.py b/genbindings.py
index 2a5c44e2c6ea7e200d5d42dcba4b8a0218454d99..a0d0ab629c6dfe3dfa9cae8e8aba1ac7517984f8 100755 (executable)
--- a/genbindings.py
+++ b/genbindings.py
@@ -2,7 +2,7 @@
 import sys, re
 
 if len(sys.argv) != 6:
 import sys, re
 
 if len(sys.argv) != 6:

-    print("USAGE: /path/to/lightning.h /path/to/bindings/output.java /path/to/bindings/enums/ /path/to/bindings/output.c debug")
+    print("USAGE: /path/to/lightning.h /path/to/bindings/output.java /path/to/bindings/ /path/to/bindings/output.c debug")

     print("debug should be true or false and indicates whether to track allocations and ensure we don't leak")
     sys.exit(1)
 
     print("debug should be true or false and indicates whether to track allocations and ensure we don't leak")
     sys.exit(1)
 


@@ -19,16 +19,19 @@ class TypeInfo:
         self.arr_access = arr_access
 
 class ConvInfo:
         self.arr_access = arr_access
 
 class ConvInfo:

-    def __init__(self, ty_info, arg_name, arg_conv, arg_conv_name, ret_conv, ret_conv_name):
+    def __init__(self, ty_info, arg_name, arg_conv, arg_conv_name, arg_conv_cleanup, ret_conv, ret_conv_name):

         assert(ty_info.c_ty is not None)
         assert(ty_info.java_ty is not None)
         assert(arg_name is not None)
         assert(ty_info.c_ty is not None)
         assert(ty_info.java_ty is not None)
         assert(arg_name is not None)

+        self.passed_as_ptr = ty_info.passed_as_ptr
+        self.rust_obj = ty_info.rust_obj

         self.c_ty = ty_info.c_ty
         self.java_ty = ty_info.java_ty
         self.java_fn_ty_arg = ty_info.java_fn_ty_arg
         self.arg_name = arg_name
         self.arg_conv = arg_conv
         self.arg_conv_name = arg_conv_name
         self.c_ty = ty_info.c_ty
         self.java_ty = ty_info.java_ty
         self.java_fn_ty_arg = ty_info.java_fn_ty_arg
         self.arg_name = arg_name
         self.arg_conv = arg_conv
         self.arg_conv_name = arg_conv_name

+        self.arg_conv_cleanup = arg_conv_cleanup

         self.ret_conv = ret_conv
         self.ret_conv_name = ret_conv_name
 
         self.ret_conv = ret_conv
         self.ret_conv_name = ret_conv_name
 


@@ -44,143 +47,184 @@ class ConvInfo:
             out_java.write(" arg")
             out_c.write(" arg")
 
             out_java.write(" arg")
             out_c.write(" arg")
 

-with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.argv[4], "w") as out_c:
-    opaque_structs = set()
-    trait_structs = set()
-    unitary_enums = set()
-
-    def camel_to_snake(s):
-        # Convert camel case to snake case, in a way that appears to match cbindgen
-        con = "_"
-        ret = ""
-        lastchar = ""
-        lastund = False
-        for char in s:
-            if lastchar.isupper():
-                if not char.isupper() and not lastund:
-                    ret = ret + "_"
-                    lastund = True
-                else:
-                    lastund = False
-                ret = ret + lastchar.lower()
+def camel_to_snake(s):
+    # Convert camel case to snake case, in a way that appears to match cbindgen
+    con = "_"
+    ret = ""
+    lastchar = ""
+    lastund = False
+    for char in s:
+        if lastchar.isupper():
+            if not char.isupper() and not lastund:
+                ret = ret + "_"
+                lastund = True

             else:
             else:

-                ret = ret + lastchar
-                if char.isupper() and not lastund:
-                    ret = ret + "_"
-                    lastund = True
-                else:
-                    lastund = False
-            lastchar = char
-            if char.isnumeric():
+                lastund = False
+            ret = ret + lastchar.lower()
+        else:
+            ret = ret + lastchar
+            if char.isupper() and not lastund:
+                ret = ret + "_"

                 lastund = True
                 lastund = True

-        return (ret + lastchar.lower()).strip("_")
-
-    var_is_arr_regex = re.compile("\(\*([A-za-z0-9_]*)\)\[([0-9]*)\]")
-    var_ty_regex = re.compile("([A-za-z_0-9]*)(.*)")
-    def java_c_types(fn_arg, ret_arr_len):
-        fn_arg = fn_arg.strip()
-        if fn_arg.startswith("MUST_USE_RES "):
-            fn_arg = fn_arg[13:]
-        is_const = False
-        if fn_arg.startswith("const "):
-            fn_arg = fn_arg[6:]
-            is_const = True
-
-        is_ptr = False
-        take_by_ptr = False
-        rust_obj = None
-        arr_access = None
-        if fn_arg.startswith("LDKThirtyTwoBytes"):
-            fn_arg = "uint8_t (*" + fn_arg[18:] + ")[32]"
-            assert var_is_arr_regex.match(fn_arg[8:])
-            rust_obj = "LDKThirtyTwoBytes"
-            arr_access = "data"
-        if fn_arg.startswith("LDKPublicKey"):
-            fn_arg = "uint8_t (*" + fn_arg[13:] + ")[33]"
-            assert var_is_arr_regex.match(fn_arg[8:])
-            rust_obj = "LDKPublicKey"
-            arr_access = "compressed_form"
-        #if fn_arg.startswith("LDKSignature"):
-        #    fn_arg = "uint8_t (*" + fn_arg[13:] + ")[64]"
-        #    assert var_is_arr_regex.match(fn_arg[8:])
-        #    rust_obj = "LDKSignature"
-
-        if fn_arg.startswith("void"):
-            java_ty = "void"
-            c_ty = "void"
-            fn_ty_arg = "V"
-            fn_arg = fn_arg[4:].strip()
-        elif fn_arg.startswith("bool"):
-            java_ty = "boolean"
-            c_ty = "jboolean"
-            fn_ty_arg = "Z"
-            fn_arg = fn_arg[4:].strip()
-        elif fn_arg.startswith("uint8_t"):
-            java_ty = "byte"
-            c_ty = "jbyte"
-            fn_ty_arg = "B"
-            fn_arg = fn_arg[7:].strip()
-        elif fn_arg.startswith("uint16_t"):
-            java_ty = "short"
-            c_ty = "jshort"
-            fn_ty_arg = "S"
-            fn_arg = fn_arg[8:].strip()
-        elif fn_arg.startswith("uint32_t"):
-            java_ty = "int"
-            c_ty = "jint"
-            fn_ty_arg = "I"
+            else:
+                lastund = False
+        lastchar = char
+        if char.isnumeric():
+            lastund = True
+    return (ret + lastchar.lower()).strip("_")
+
+unitary_enums = set()
+var_is_arr_regex = re.compile("\(\*([A-za-z0-9_]*)\)\[([a-z0-9]*)\]")
+var_ty_regex = re.compile("([A-za-z_0-9]*)(.*)")
+def java_c_types(fn_arg, ret_arr_len):
+    fn_arg = fn_arg.strip()
+    if fn_arg.startswith("MUST_USE_RES "):
+        fn_arg = fn_arg[13:]
+    is_const = False
+    if fn_arg.startswith("const "):
+        fn_arg = fn_arg[6:]
+        is_const = True
+
+    is_ptr = False
+    take_by_ptr = False
+    rust_obj = None
+    arr_access = None
+    if fn_arg.startswith("LDKThirtyTwoBytes"):
+        fn_arg = "uint8_t (*" + fn_arg[18:] + ")[32]"
+        assert var_is_arr_regex.match(fn_arg[8:])
+        rust_obj = "LDKThirtyTwoBytes"
+        arr_access = "data"
+    if fn_arg.startswith("LDKPublicKey"):
+        fn_arg = "uint8_t (*" + fn_arg[13:] + ")[33]"
+        assert var_is_arr_regex.match(fn_arg[8:])
+        rust_obj = "LDKPublicKey"
+        arr_access = "compressed_form"
+    if fn_arg.startswith("LDKSecretKey"):
+        fn_arg = "uint8_t (*" + fn_arg[13:] + ")[32]"
+        assert var_is_arr_regex.match(fn_arg[8:])
+        rust_obj = "LDKSecretKey"
+        arr_access = "bytes"
+    if fn_arg.startswith("LDKSignature"):
+        fn_arg = "uint8_t (*" + fn_arg[13:] + ")[64]"
+        assert var_is_arr_regex.match(fn_arg[8:])
+        rust_obj = "LDKSignature"
+        arr_access = "compact_form"
+    if fn_arg.startswith("LDKThreeBytes"):
+        fn_arg = "uint8_t (*" + fn_arg[14:] + ")[3]"
+        assert var_is_arr_regex.match(fn_arg[8:])
+        rust_obj = "LDKThreeBytes"
+        arr_access = "data"
+    if fn_arg.startswith("LDKu8slice"):
+        fn_arg = "uint8_t (*" + fn_arg[11:] + ")[datalen]"
+        assert var_is_arr_regex.match(fn_arg[8:])
+        rust_obj = "LDKu8slice"
+        arr_access = "data"
+
+    if fn_arg.startswith("void"):
+        java_ty = "void"
+        c_ty = "void"
+        fn_ty_arg = "V"
+        fn_arg = fn_arg[4:].strip()
+    elif fn_arg.startswith("bool"):
+        java_ty = "boolean"
+        c_ty = "jboolean"
+        fn_ty_arg = "Z"
+        fn_arg = fn_arg[4:].strip()
+    elif fn_arg.startswith("uint8_t"):
+        java_ty = "byte"
+        c_ty = "jbyte"
+        fn_ty_arg = "B"
+        fn_arg = fn_arg[7:].strip()
+    elif fn_arg.startswith("uint16_t"):
+        java_ty = "short"
+        c_ty = "jshort"
+        fn_ty_arg = "S"
+        fn_arg = fn_arg[8:].strip()
+    elif fn_arg.startswith("uint32_t"):
+        java_ty = "int"
+        c_ty = "jint"
+        fn_ty_arg = "I"
+        fn_arg = fn_arg[8:].strip()
+    elif fn_arg.startswith("uint64_t") or fn_arg.startswith("uintptr_t"):
+        java_ty = "long"
+        c_ty = "jlong"
+        fn_ty_arg = "J"
+        if fn_arg.startswith("uint64_t"):

             fn_arg = fn_arg[8:].strip()
             fn_arg = fn_arg[8:].strip()

-        elif fn_arg.startswith("uint64_t") or fn_arg.startswith("uintptr_t"):
+        else:
+            fn_arg = fn_arg[9:].strip()
+    elif is_const and fn_arg.startswith("char *"):
+        java_ty = "String"
+        c_ty = "const char*"
+        fn_ty_arg = "Ljava/lang/String;"
+        fn_arg = fn_arg[6:].strip()
+    else:
+        ma = var_ty_regex.match(fn_arg)
+        if ma.group(1).strip() in unitary_enums:
+            java_ty = ma.group(1).strip()
+            c_ty = "jclass"
+            fn_ty_arg = "Lorg/ldk/enums/" + ma.group(1).strip() + ";"
+            fn_arg = ma.group(2).strip()
+            rust_obj = ma.group(1).strip()
+            take_by_ptr = True
+        else:

             java_ty = "long"
             c_ty = "jlong"
             fn_ty_arg = "J"
             java_ty = "long"
             c_ty = "jlong"
             fn_ty_arg = "J"

-            if fn_arg.startswith("uint64_t"):
-                fn_arg = fn_arg[8:].strip()
-            else:
-                fn_arg = fn_arg[9:].strip()
-        elif is_const and fn_arg.startswith("char *"):
-            java_ty = "String"
-            c_ty = "const char*"
-            fn_ty_arg = "Ljava/lang/String;"
-            fn_arg = fn_arg[6:].strip()
-        else:
-            ma = var_ty_regex.match(fn_arg)
-            if ma.group(1).strip() in unitary_enums:
-                java_ty = ma.group(1).strip()
-                c_ty = "jclass"
-                fn_ty_arg = "Lorg/ldk/enums/" + ma.group(1).strip() + ";"
-                fn_arg = ma.group(2).strip()
-                rust_obj = ma.group(1).strip()
-                take_by_ptr = True
+            fn_arg = ma.group(2).strip()
+            rust_obj = ma.group(1).strip()
+            take_by_ptr = True
+
+    if fn_arg.startswith(" *") or fn_arg.startswith("*"):
+        fn_arg = fn_arg.replace("*", "").strip()
+        is_ptr = True
+        c_ty = "jlong"
+        java_ty = "long"
+        fn_ty_arg = "J"
+
+    var_is_arr = var_is_arr_regex.match(fn_arg)
+    if var_is_arr is not None or ret_arr_len is not None:
+        assert(not take_by_ptr)
+        assert(not is_ptr)
+        java_ty = java_ty + "[]"
+        c_ty = c_ty + "Array"
+        if var_is_arr is not None:
+            if var_is_arr.group(1) == "":
+                return TypeInfo(rust_obj=rust_obj, java_ty=java_ty, java_fn_ty_arg="[" + fn_ty_arg, c_ty=c_ty,
+                    passed_as_ptr=False, is_ptr=False, var_name="arg", arr_len=var_is_arr.group(2), arr_access=arr_access)
+            return TypeInfo(rust_obj=rust_obj, java_ty=java_ty, java_fn_ty_arg="[" + fn_ty_arg, c_ty=c_ty,
+                passed_as_ptr=False, is_ptr=False, var_name=var_is_arr.group(1), arr_len=var_is_arr.group(2), arr_access=arr_access)
+    return TypeInfo(rust_obj=rust_obj, java_ty=java_ty, java_fn_ty_arg=fn_ty_arg, c_ty=c_ty, passed_as_ptr=is_ptr or take_by_ptr,
+        is_ptr=is_ptr, var_name=fn_arg, arr_len=None, arr_access=None)
+
+
+
+fn_ptr_regex = re.compile("^extern const ([A-Za-z_0-9\* ]*) \(\*(.*)\)\((.*)\);$")
+fn_ret_arr_regex = re.compile("(.*) \(\*(.*)\((.*)\)\)\[([0-9]*)\];$")
+reg_fn_regex = re.compile("([A-Za-z_0-9\* ]* \*?)([a-zA-Z_0-9]*)\((.*)\);$")
+clone_fns = set()
+constructor_fns = {}
+with open(sys.argv[1]) as in_h:
+    for line in in_h:
+        reg_fn = reg_fn_regex.match(line)
+        if reg_fn is not None:
+            if reg_fn.group(2).endswith("_clone"):
+                clone_fns.add(reg_fn.group(2))

             else:
             else:

-                java_ty = "long"
-                c_ty = "jlong"
-                fn_ty_arg = "J"
-                fn_arg = ma.group(2).strip()
-                rust_obj = ma.group(1).strip()
-                take_by_ptr = True
-
-        if fn_arg.startswith(" *") or fn_arg.startswith("*"):
-            fn_arg = fn_arg.replace("*", "").strip()
-            is_ptr = True
-            c_ty = "jlong"
-            java_ty = "long"
-            fn_ty_arg = "J"
+                rty = java_c_types(reg_fn.group(1), None)
+                if rty.rust_obj is not None and reg_fn.group(2) == rty.rust_obj.replace("LDK", "") + "_new":
+                    constructor_fns[rty.rust_obj] = reg_fn.group(3)
+            continue
+        arr_fn = fn_ret_arr_regex.match(line)
+        if arr_fn is not None:
+            if arr_fn.group(2).endswith("_clone"):
+                clone_fns.add(arr_fn.group(2))
+            # No object constructors return arrays, as then they wouldn't be an object constructor
+            continue

 
 

-        var_is_arr = var_is_arr_regex.match(fn_arg)
-        if var_is_arr is not None or ret_arr_len is not None:
-            assert(not take_by_ptr)
-            assert(not is_ptr)
-            java_ty = java_ty + "[]"
-            c_ty = c_ty + "Array"
-            if var_is_arr is not None:
-                if var_is_arr.group(1) == "":
-                    return TypeInfo(rust_obj=rust_obj, java_ty=java_ty, java_fn_ty_arg="[" + fn_ty_arg, c_ty=c_ty,
-                        passed_as_ptr=False, is_ptr=False, var_name="arg", arr_len=var_is_arr.group(2), arr_access=arr_access)
-                return TypeInfo(rust_obj=rust_obj, java_ty=java_ty, java_fn_ty_arg="[" + fn_ty_arg, c_ty=c_ty,
-                    passed_as_ptr=False, is_ptr=False, var_name=var_is_arr.group(1), arr_len=var_is_arr.group(2), arr_access=arr_access)
-        return TypeInfo(rust_obj=rust_obj, java_ty=java_ty, java_fn_ty_arg=fn_ty_arg, c_ty=c_ty, passed_as_ptr=is_ptr or take_by_ptr,
-            is_ptr=is_ptr, var_name=fn_arg, arr_len=None, arr_access=None)
+with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.argv[4], "w") as out_c:
+    opaque_structs = set()
+    trait_structs = set()

 
     def map_type(fn_arg, print_void, ret_arr_len, is_free):
         ty_info = java_c_types(fn_arg, ret_arr_len)
 
     def map_type(fn_arg, print_void, ret_arr_len, is_free):
         ty_info = java_c_types(fn_arg, ret_arr_len)


@@ -188,7 +232,8 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg
         if ty_info.c_ty == "void":
             if not print_void:
                 return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
         if ty_info.c_ty == "void":
             if not print_void:
                 return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,

-                    arg_conv = None, arg_conv_name = None, ret_conv = None, ret_conv_name = None)
+                    arg_conv = None, arg_conv_name = None, arg_conv_cleanup = None,
+                    ret_conv = None, ret_conv_name = None)

 
         if ty_info.c_ty.endswith("Array"):
             arr_len = ty_info.arr_len
 
         if ty_info.c_ty.endswith("Array"):
             arr_len = ty_info.arr_len


@@ -198,19 +243,30 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg
                 arr_name = "ret"
                 arr_len = ret_arr_len
             assert(ty_info.c_ty == "jbyteArray")
                 arr_name = "ret"
                 arr_len = ret_arr_len
             assert(ty_info.c_ty == "jbyteArray")

-            if ty_info.rust_obj is not None:
-                arg_conv = ty_info.rust_obj + " " + arr_name + "_ref;\n" + "(*_env)->GetByteArrayRegion (_env, " + arr_name + ", 0, " + arr_len + ", " + arr_name + "_ref." + ty_info.arr_access + ");"
-                arr_access = ("", "." + ty_info.arr_access)
+            ret_conv = ("jbyteArray " + arr_name + "_arr = (*_env)->NewByteArray(_env, " + arr_len + ");\n" + "(*_env)->SetByteArrayRegion(_env, " + arr_name + "_arr, 0, " + arr_len + ", ", "")
+            arg_conv_cleanup = None
+            if not arr_len.isdigit():
+                arg_conv = ty_info.rust_obj + " " + arr_name + "_ref;\n"
+                arg_conv = arg_conv + arr_name + "_ref." + ty_info.arr_access + " = (*_env)->GetByteArrayElements (_env, " + arr_name + ", NULL);\n"
+                arg_conv = arg_conv + arr_name + "_ref." + arr_len + " = (*_env)->GetArrayLength (_env, " + arr_name + ");"
+                arg_conv_cleanup = "(*_env)->ReleaseByteArrayElements(_env, " + arr_name + ", (int8_t*)" + arr_name + "_ref." + ty_info.arr_access + ", 0);"
+                arr_access = "." + ty_info.arr_access
+                ret_conv = (ty_info.rust_obj + " " + arr_name + "_var = ", "")
+                ret_conv = (ret_conv[0], ";\njbyteArray " + arr_name + "_arr = (*_env)->NewByteArray(_env, " + arr_name + "_var." + arr_len + ");\n")
+                ret_conv = (ret_conv[0], ret_conv[1] + "(*_env)->SetByteArrayRegion(_env, " + arr_name + "_arr, 0, " + arr_name + "_var." + arr_len + ", " + arr_name + "_var." + ty_info.arr_access + ");")
+            elif ty_info.rust_obj is not None:
+                arg_conv = ty_info.rust_obj + " " + arr_name + "_ref;\n"
+                arg_conv = arg_conv + "CHECK((*_env)->GetArrayLength (_env, " + arr_name + ") == " + arr_len + ");\n"
+                arg_conv = arg_conv + "(*_env)->GetByteArrayRegion (_env, " + arr_name + ", 0, " + arr_len + ", " + arr_name + "_ref." + ty_info.arr_access + ");"
+                ret_conv = (ret_conv[0], "." + ty_info.arr_access + ");")

             else:
             else:

-                arg_conv = "unsigned char " + arr_name + "_arr[" + arr_len + "];\n" + "(*_env)->GetByteArrayRegion (_env, " + arr_name + ", 0, " + arr_len + ", " + arr_name + "_arr);\n" + "unsigned char (*" + arr_name + "_ref)[" + arr_len + "] = &" + arr_name + "_arr;"
-                arr_access = ("*", "")
+                arg_conv = "unsigned char " + arr_name + "_arr[" + arr_len + "];\n"
+                arg_conv = arg_conv + "CHECK((*_env)->GetArrayLength (_env, " + arr_name + ") == " + arr_len + ");\n"
+                arg_conv = arg_conv + "(*_env)->GetByteArrayRegion (_env, " + arr_name + ", 0, " + arr_len + ", " + arr_name + "_arr);\n" + "unsigned char (*" + arr_name + "_ref)[" + arr_len + "] = &" + arr_name + "_arr;"
+                ret_conv = (ret_conv[0] + "*", ");")

             return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
             return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,

-                arg_conv = arg_conv,
-                arg_conv_name = arr_name + "_ref",
-                ret_conv = ("jbyteArray " + arr_name + "_arr = (*_env)->NewByteArray(_env, " + arr_len + ");\n" +
-                    "(*_env)->SetByteArrayRegion(_env, " + arr_name + "_arr, 0, " + arr_len + ", " + arr_access[0],
-                    arr_access[1] + ");"),
-                ret_conv_name = arr_name + "_arr")
+                arg_conv = arg_conv, arg_conv_name = arr_name + "_ref", arg_conv_cleanup = arg_conv_cleanup,
+                ret_conv = ret_conv, ret_conv_name = arr_name + "_arr")

         elif ty_info.var_name != "":
             # If we have a parameter name, print it (noting that it may indicate its a pointer)
             if ty_info.rust_obj is not None:
         elif ty_info.var_name != "":
             # If we have a parameter name, print it (noting that it may indicate its a pointer)
             if ty_info.rust_obj is not None:


@@ -218,16 +274,24 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg
                 opaque_arg_conv = ty_info.rust_obj + " " + ty_info.var_name + "_conv;\n"
                 opaque_arg_conv = opaque_arg_conv + ty_info.var_name + "_conv.inner = (void*)(" + ty_info.var_name + " & (~1));\n"
                 opaque_arg_conv = opaque_arg_conv + ty_info.var_name + "_conv.is_owned = (" + ty_info.var_name + " & 1) || (" + ty_info.var_name + " == 0);"
                 opaque_arg_conv = ty_info.rust_obj + " " + ty_info.var_name + "_conv;\n"
                 opaque_arg_conv = opaque_arg_conv + ty_info.var_name + "_conv.inner = (void*)(" + ty_info.var_name + " & (~1));\n"
                 opaque_arg_conv = opaque_arg_conv + ty_info.var_name + "_conv.is_owned = (" + ty_info.var_name + " & 1) || (" + ty_info.var_name + " == 0);"

+                if not ty_info.is_ptr and not is_free:
+                    if (ty_info.rust_obj.replace("LDK", "") + "_clone") in clone_fns:
+                        # TODO: This is a bit too naive, even with the checks above, we really need to know if rust wants a ref or not, not just if its pass as a ptr.
+                        opaque_arg_conv = opaque_arg_conv + "\nif (" + ty_info.var_name + "_conv.inner != NULL)\n"
+                        opaque_arg_conv = opaque_arg_conv + "\t" + ty_info.var_name + "_conv = " + ty_info.rust_obj.replace("LDK", "") + "_clone(&" + ty_info.var_name + "_conv);"
+                    elif ty_info.passed_as_ptr:
+                        opaque_arg_conv = opaque_arg_conv + "\n// Warning: we may need a move here but can't clone!"

                 if not ty_info.is_ptr:
                     if ty_info.rust_obj in unitary_enums:
                         return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
                             arg_conv = ty_info.rust_obj + " " + ty_info.var_name + "_conv = " + ty_info.rust_obj + "_from_java(_env, " + ty_info.var_name + ");",
                             arg_conv_name = ty_info.var_name + "_conv",
                 if not ty_info.is_ptr:
                     if ty_info.rust_obj in unitary_enums:
                         return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
                             arg_conv = ty_info.rust_obj + " " + ty_info.var_name + "_conv = " + ty_info.rust_obj + "_from_java(_env, " + ty_info.var_name + ");",
                             arg_conv_name = ty_info.var_name + "_conv",

+                            arg_conv_cleanup = None,

                             ret_conv = ("jclass " + ty_info.var_name + "_conv = " + ty_info.rust_obj + "_to_java(_env, ", ");"),
                             ret_conv_name = ty_info.var_name + "_conv")
                     if ty_info.rust_obj in opaque_structs:
                             ret_conv = ("jclass " + ty_info.var_name + "_conv = " + ty_info.rust_obj + "_to_java(_env, ", ");"),
                             ret_conv_name = ty_info.var_name + "_conv")
                     if ty_info.rust_obj in opaque_structs:

-                        ret_conv_suf = ";\nDO_ASSERT((((long)" + ty_info.var_name + "_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.\n"
-                        ret_conv_suf = ret_conv_suf + "DO_ASSERT((((long)&" + ty_info.var_name + "_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.\n"
+                        ret_conv_suf = ";\nCHECK((((long)" + ty_info.var_name + "_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.\n"
+                        ret_conv_suf = ret_conv_suf + "CHECK((((long)&" + ty_info.var_name + "_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.\n"

                         ret_conv_suf = ret_conv_suf + "long " + ty_info.var_name + "_ref;\n"
                         ret_conv_suf = ret_conv_suf + "if (" + ty_info.var_name + "_var.is_owned) {\n"
                         ret_conv_suf = ret_conv_suf + "\t" + ty_info.var_name + "_ref = (long)" + ty_info.var_name + "_var.inner | 1;\n"
                         ret_conv_suf = ret_conv_suf + "long " + ty_info.var_name + "_ref;\n"
                         ret_conv_suf = ret_conv_suf + "if (" + ty_info.var_name + "_var.is_owned) {\n"
                         ret_conv_suf = ret_conv_suf + "\t" + ty_info.var_name + "_ref = (long)" + ty_info.var_name + "_var.inner | 1;\n"


@@ -235,7 +299,7 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg
                         ret_conv_suf = ret_conv_suf + "\t" + ty_info.var_name + "_ref = (long)&" + ty_info.var_name + "_var;\n"
                         ret_conv_suf = ret_conv_suf + "}"
                         return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
                         ret_conv_suf = ret_conv_suf + "\t" + ty_info.var_name + "_ref = (long)&" + ty_info.var_name + "_var;\n"
                         ret_conv_suf = ret_conv_suf + "}"
                         return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,

-                            arg_conv = opaque_arg_conv, arg_conv_name = ty_info.var_name + "_conv",
+                            arg_conv = opaque_arg_conv, arg_conv_name = ty_info.var_name + "_conv", arg_conv_cleanup = None,

                             ret_conv = (ty_info.rust_obj + " " + ty_info.var_name + "_var = ", ret_conv_suf),
                             ret_conv_name = ty_info.var_name + "_ref")
                     base_conv = ty_info.rust_obj + " " + ty_info.var_name + "_conv = *(" + ty_info.rust_obj + "*)" + ty_info.var_name + ";";
                             ret_conv = (ty_info.rust_obj + " " + ty_info.var_name + "_var = ", ret_conv_suf),
                             ret_conv_name = ty_info.var_name + "_ref")
                     base_conv = ty_info.rust_obj + " " + ty_info.var_name + "_conv = *(" + ty_info.rust_obj + "*)" + ty_info.var_name + ";";


@@ -247,48 +311,47 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg
                         else:
                             base_conv = base_conv + "\n" + "FREE((void*)" + ty_info.var_name + ");"
                         return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
                         else:
                             base_conv = base_conv + "\n" + "FREE((void*)" + ty_info.var_name + ");"
                         return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,

-                            arg_conv = base_conv,
-                            arg_conv_name = ty_info.var_name + "_conv",
+                            arg_conv = base_conv, arg_conv_name = ty_info.var_name + "_conv", arg_conv_cleanup = None,

                             ret_conv = ("CANT PASS TRAIT TO Java?", ""), ret_conv_name = "NO CONV POSSIBLE")
                     if ty_info.rust_obj != "LDKu8slice":
                         # Don't bother free'ing slices passed in - Rust doesn't auto-free the
                         # underlying unlike Vecs, and it gives Java more freedom.
                         base_conv = base_conv + "\nFREE((void*)" + ty_info.var_name + ");";
                     return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
                             ret_conv = ("CANT PASS TRAIT TO Java?", ""), ret_conv_name = "NO CONV POSSIBLE")
                     if ty_info.rust_obj != "LDKu8slice":
                         # Don't bother free'ing slices passed in - Rust doesn't auto-free the
                         # underlying unlike Vecs, and it gives Java more freedom.
                         base_conv = base_conv + "\nFREE((void*)" + ty_info.var_name + ");";
                     return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,

-                        arg_conv = base_conv, arg_conv_name = ty_info.var_name + "_conv",
+                        arg_conv = base_conv, arg_conv_name = ty_info.var_name + "_conv", arg_conv_cleanup = None,

                         ret_conv = ("long " + ty_info.var_name + "_ref = (long)&", ";"), ret_conv_name = ty_info.var_name + "_ref")
                 else:
                     assert(not is_free)
                     if ty_info.rust_obj in opaque_structs:
                         return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
                         ret_conv = ("long " + ty_info.var_name + "_ref = (long)&", ";"), ret_conv_name = ty_info.var_name + "_ref")
                 else:
                     assert(not is_free)
                     if ty_info.rust_obj in opaque_structs:
                         return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,

-                            arg_conv = opaque_arg_conv, arg_conv_name = "&" + ty_info.var_name + "_conv",
+                            arg_conv = opaque_arg_conv, arg_conv_name = "&" + ty_info.var_name + "_conv", arg_conv_cleanup = None,

                             ret_conv = None, ret_conv_name = None) # its a pointer, no conv needed
                     return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
                         arg_conv = ty_info.rust_obj + "* " + ty_info.var_name + "_conv = (" + ty_info.rust_obj + "*)" + ty_info.var_name + ";",
                             ret_conv = None, ret_conv_name = None) # its a pointer, no conv needed
                     return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
                         arg_conv = ty_info.rust_obj + "* " + ty_info.var_name + "_conv = (" + ty_info.rust_obj + "*)" + ty_info.var_name + ";",

-                        arg_conv_name = ty_info.var_name + "_conv",
+                        arg_conv_name = ty_info.var_name + "_conv", arg_conv_cleanup = None,

                         ret_conv = None, ret_conv_name = None) # its a pointer, no conv needed
             elif ty_info.is_ptr:
                 return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
                         ret_conv = None, ret_conv_name = None) # its a pointer, no conv needed
             elif ty_info.is_ptr:
                 return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,

-                    arg_conv = None, arg_conv_name = ty_info.var_name, ret_conv = None, ret_conv_name = None)
+                    arg_conv = None, arg_conv_name = ty_info.var_name, arg_conv_cleanup = None, ret_conv = None, ret_conv_name = None)

             elif ty_info.java_ty == "String":
                 return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
             elif ty_info.java_ty == "String":
                 return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,

-                    arg_conv = None, arg_conv_name = None,
+                    arg_conv = None, arg_conv_name = None, arg_conv_cleanup = None,

                     ret_conv = ("jstring " + ty_info.var_name + "_conv = (*_env)->NewStringUTF(_env, ", ");"), ret_conv_name = ty_info.var_name + "_conv")
             else:
                 return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
                     ret_conv = ("jstring " + ty_info.var_name + "_conv = (*_env)->NewStringUTF(_env, ", ");"), ret_conv_name = ty_info.var_name + "_conv")
             else:
                 return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,

-                    arg_conv = None, arg_conv_name = ty_info.var_name, ret_conv = None, ret_conv_name = None)
+                    arg_conv = None, arg_conv_name = ty_info.var_name, arg_conv_cleanup = None, ret_conv = None, ret_conv_name = None)

         elif not print_void:
             # We don't have a parameter name, and want one, just call it arg
             if ty_info.rust_obj is not None:
                 assert(not is_free or ty_info.rust_obj not in opaque_structs);
                 return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
                     arg_conv = ty_info.rust_obj + " arg_conv = *(" + ty_info.rust_obj + "*)arg;\nFREE((void*)arg);",
         elif not print_void:
             # We don't have a parameter name, and want one, just call it arg
             if ty_info.rust_obj is not None:
                 assert(not is_free or ty_info.rust_obj not in opaque_structs);
                 return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
                     arg_conv = ty_info.rust_obj + " arg_conv = *(" + ty_info.rust_obj + "*)arg;\nFREE((void*)arg);",

-                    arg_conv_name = "arg_conv",
+                    arg_conv_name = "arg_conv", arg_conv_cleanup = None,

                     ret_conv = None, ret_conv_name = None)
             else:
                 assert(not is_free)
                 return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
                     ret_conv = None, ret_conv_name = None)
             else:
                 assert(not is_free)
                 return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,

-                    arg_conv = None, arg_conv_name = "arg", ret_conv = None, ret_conv_name = None)
+                    arg_conv = None, arg_conv_name = "arg", arg_conv_cleanup = None, ret_conv = None, ret_conv_name = None)

         else:
             # We don't have a parameter name, and don't want one (cause we're returning)
             if ty_info.rust_obj is not None:
         else:
             # We don't have a parameter name, and don't want one (cause we're returning)
             if ty_info.rust_obj is not None:


@@ -296,7 +359,7 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg
                     if ty_info.rust_obj in unitary_enums:
                         return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
                             arg_conv = ty_info.rust_obj + " ret = " + ty_info.rust_obj + "_from_java(_env, " + ty_info.var_name + ");",
                     if ty_info.rust_obj in unitary_enums:
                         return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
                             arg_conv = ty_info.rust_obj + " ret = " + ty_info.rust_obj + "_from_java(_env, " + ty_info.var_name + ");",

-                            arg_conv_name = "ret",
+                            arg_conv_name = "ret", arg_conv_cleanup = None,

                             ret_conv = ("jclass ret = " + ty_info.rust_obj + "_to_java(_env, ", ");"), ret_conv_name = "ret")
                     if ty_info.rust_obj in opaque_structs:
                         # If we're returning a newly-allocated struct, we don't want Rust to ever
                             ret_conv = ("jclass ret = " + ty_info.rust_obj + "_to_java(_env, ", ");"), ret_conv_name = "ret")
                     if ty_info.rust_obj in opaque_structs:
                         # If we're returning a newly-allocated struct, we don't want Rust to ever


@@ -306,27 +369,31 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg
                         return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
                             ret_conv = (ty_info.rust_obj + " ret = ", ";"),
                             ret_conv_name = "((long)ret.inner) | (ret.is_owned ? 1 : 0)",
                         return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
                             ret_conv = (ty_info.rust_obj + " ret = ", ";"),
                             ret_conv_name = "((long)ret.inner) | (ret.is_owned ? 1 : 0)",

-                            arg_conv = None, arg_conv_name = None)
+                            arg_conv = None, arg_conv_name = None, arg_conv_cleanup = None)

                     else:
                         return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
                             ret_conv = (ty_info.rust_obj + "* ret = MALLOC(sizeof(" + ty_info.rust_obj + "), \"" + ty_info.rust_obj + "\");\n*ret = ", ";"),
                             ret_conv_name = "(long)ret",
                     else:
                         return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
                             ret_conv = (ty_info.rust_obj + "* ret = MALLOC(sizeof(" + ty_info.rust_obj + "), \"" + ty_info.rust_obj + "\");\n*ret = ", ";"),
                             ret_conv_name = "(long)ret",

-                            arg_conv = None, arg_conv_name = None)
+                            arg_conv = None, arg_conv_name = None, arg_conv_cleanup = None)

                 else:
                     return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
                         ret_conv = ("long ret = (long)", ";"), ret_conv_name = "ret",
                 else:
                     return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
                         ret_conv = ("long ret = (long)", ";"), ret_conv_name = "ret",

-                        arg_conv = None, arg_conv_name = None)
+                        arg_conv = None, arg_conv_name = None, arg_conv_cleanup = None)

             else:
                 return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
             else:
                 return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,

-                    arg_conv = None, arg_conv_name = None, ret_conv = None, ret_conv_name = None)
+                    arg_conv = None, arg_conv_name = None, arg_conv_cleanup = None, ret_conv = None, ret_conv_name = None)

 
     def map_fn(line, re_match, ret_arr_len, c_call_string):
         out_java.write("\t// " + line)
         out_java.write("\tpublic static native ")
         out_c.write("JNIEXPORT ")
 
 
     def map_fn(line, re_match, ret_arr_len, c_call_string):
         out_java.write("\t// " + line)
         out_java.write("\tpublic static native ")
         out_c.write("JNIEXPORT ")
 

+        is_free = re_match.group(2).endswith("_free")
+        struct_meth = re_match.group(2).split("_")[0]
+

         ret_info = map_type(re_match.group(1), True, ret_arr_len, False)
         ret_info.print_ty()
         ret_info = map_type(re_match.group(1), True, ret_arr_len, False)
         ret_info.print_ty()

+

         if ret_info.ret_conv is not None:
             ret_conv_pfx, ret_conv_sfx = ret_info.ret_conv
 
         if ret_info.ret_conv is not None:
             ret_conv_pfx, ret_conv_sfx = ret_info.ret_conv
 


@@ -334,28 +401,93 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg
         out_c.write(" JNICALL Java_org_ldk_impl_bindings_" + re_match.group(2).replace('_', '_1') + "(JNIEnv * _env, jclass _b")
 
         arg_names = []
         out_c.write(" JNICALL Java_org_ldk_impl_bindings_" + re_match.group(2).replace('_', '_1') + "(JNIEnv * _env, jclass _b")
 
         arg_names = []

+        default_constructor_args = {}
+        takes_self = False
+        args_known = not ret_info.passed_as_ptr or ret_info.rust_obj in opaque_structs or ret_info.rust_obj in trait_structs

         for idx, arg in enumerate(re_match.group(3).split(',')):
             if idx != 0:
                 out_java.write(", ")
             if arg != "void":
                 out_c.write(", ")
         for idx, arg in enumerate(re_match.group(3).split(',')):
             if idx != 0:
                 out_java.write(", ")
             if arg != "void":
                 out_c.write(", ")

-            arg_conv_info = map_type(arg, False, None, re_match.group(2).endswith("_free"))
+            arg_conv_info = map_type(arg, False, None, is_free)

             if arg_conv_info.c_ty != "void":
                 arg_conv_info.print_ty()
                 arg_conv_info.print_name()
             if arg_conv_info.c_ty != "void":
                 arg_conv_info.print_ty()
                 arg_conv_info.print_name()

+            if arg_conv_info.arg_name == "this_arg":
+                takes_self = True
+            if arg_conv_info.passed_as_ptr and not arg_conv_info.rust_obj in opaque_structs:
+                if not arg_conv_info.rust_obj in trait_structs and not arg_conv_info.rust_obj in unitary_enums:
+                    args_known = False
+            if arg_conv_info.arg_conv is not None and "Warning" in arg_conv_info.arg_conv:
+                if arg_conv_info.rust_obj in constructor_fns:
+                    assert not is_free
+                    for explode_arg in constructor_fns[arg_conv_info.rust_obj].split(','):
+                        explode_arg_conv = map_type(explode_arg, False, None, False)
+                        if explode_arg_conv.c_ty == "void":
+                            # We actually want to handle this case, but for now its only used in NetGraphMsgHandler::new()
+                            # which ends up resulting in a redundant constructor - both without arguments for the NetworkGraph.
+                            args_known = False
+                        assert explode_arg_conv.arg_name != "this_arg"
+                        if explode_arg_conv.passed_as_ptr and not explode_arg_conv.rust_obj in trait_structs:
+                            args_known = False
+                        if not arg_conv_info.arg_name in default_constructor_args:
+                            default_constructor_args[arg_conv_info.arg_name] = []
+                        default_constructor_args[arg_conv_info.arg_name].append(explode_arg_conv)
+                else:
+                    args_known = False

             arg_names.append(arg_conv_info)
 
             arg_names.append(arg_conv_info)
 

+        out_java_struct = None
+        if ("LDK" + struct_meth in opaque_structs or "LDK" + struct_meth in trait_structs) and not is_free:
+            out_java_struct = open(sys.argv[3] + "/structs/" + struct_meth + ".java", "a")
+            if not args_known:
+                out_java_struct.write("\t// Skipped " + re_match.group(2) + "\n")
+                out_java_struct.close()
+                out_java_struct = None
+            else:
+                out_java_struct.write("\tpublic ")
+                meth_n = re_match.group(2)[len(struct_meth) + 1:]
+                if ret_info.rust_obj == "LDK" + struct_meth:
+                    out_java_struct.write(struct_meth + "(")
+                elif ret_info.rust_obj in opaque_structs or ret_info.rust_obj in trait_structs:
+                    out_java_struct.write(ret_info.rust_obj.replace("LDK", "") + " " + meth_n + "(")
+                else:
+                    out_java_struct.write(ret_info.java_ty + " " + meth_n + "(")
+                for idx, arg in enumerate(arg_names):
+                    if idx != 0:
+                        if not takes_self or idx > 1:
+                            out_java_struct.write(", ")
+                    if arg.java_ty != "void" and arg.arg_name != "this_arg":
+                        if arg.arg_name in default_constructor_args:
+                            for explode_idx, explode_arg in enumerate(default_constructor_args[arg.arg_name]):
+                                if explode_idx != 0:
+                                    out_java_struct.write(", ")
+                                assert explode_arg.rust_obj in opaque_structs or explode_arg.rust_obj in trait_structs
+                                out_java_struct.write(explode_arg.rust_obj.replace("LDK", "") + " " + arg.arg_name + "_" + explode_arg.arg_name)
+                        elif arg.passed_as_ptr:
+                            if arg.rust_obj in opaque_structs or arg.rust_obj in trait_structs:
+                                out_java_struct.write(arg.rust_obj.replace("LDK", "") + " " + arg.arg_name)
+                            else:
+                                out_java_struct.write(arg.rust_obj + " " + arg.arg_name)
+                        else:
+                            out_java_struct.write(arg.java_ty + " " + arg.arg_name)
+
+

         out_java.write(");\n")
         out_c.write(") {\n")
         out_java.write(");\n")
         out_c.write(") {\n")

+        if out_java_struct is not None:
+            out_java_struct.write(") {\n")

 
         for info in arg_names:
             if info.arg_conv is not None:
 
         for info in arg_names:
             if info.arg_conv is not None:

-                out_c.write("\t" + info.arg_conv.replace('\n', "\n\t") + "\n");
+                out_c.write("\t" + info.arg_conv.replace('\n', "\n\t") + "\n")

 
         if ret_info.ret_conv is not None:
 
         if ret_info.ret_conv is not None:

-            out_c.write("\t" + ret_conv_pfx.replace('\n', '\n\t'));
+            out_c.write("\t" + ret_conv_pfx.replace('\n', '\n\t'))
+        elif ret_info.c_ty != "void":
+            out_c.write("\t" + ret_info.c_ty + " ret_val = ")

         else:
         else:

-            out_c.write("\treturn ");
+            out_c.write("\t")

 
         if c_call_string is None:
             out_c.write(re_match.group(2) + "(")
 
         if c_call_string is None:
             out_c.write(re_match.group(2) + "(")


@@ -371,13 +503,73 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg
         out_c.write(")")
         if ret_info.ret_conv is not None:
             out_c.write(ret_conv_sfx.replace('\n', '\n\t'))
         out_c.write(")")
         if ret_info.ret_conv is not None:
             out_c.write(ret_conv_sfx.replace('\n', '\n\t'))

-            out_c.write("\n\treturn " + ret_info.ret_conv_name + ";")

         else:
             out_c.write(";")
         else:
             out_c.write(";")

+        for info in arg_names:
+            if info.arg_conv_cleanup is not None:
+                out_c.write("\n\t" + info.arg_conv_cleanup.replace("\n", "\n\t"))
+        if ret_info.ret_conv is not None:
+            out_c.write("\n\treturn " + ret_info.ret_conv_name + ";")
+        elif ret_info.c_ty != "void":
+            out_c.write("\n\treturn ret_val;")

         out_c.write("\n}\n\n")
         out_c.write("\n}\n\n")

+        if out_java_struct is not None:
+            out_java_struct.write("\t\t")
+            if ret_info.rust_obj == "LDK" + struct_meth:
+                out_java_struct.write("super(")
+            elif ret_info.java_ty != "void" and not ret_info.passed_as_ptr:
+                out_java_struct.write(ret_info.java_ty + " ret = ")
+            elif ret_info.java_ty != "void":
+                out_java_struct.write(ret_info.rust_obj.replace("LDK", "") + " ret = ")
+                if ret_info.rust_obj in opaque_structs or ret_info.rust_obj in trait_structs:
+                    out_java_struct.write("new " + ret_info.rust_obj.replace("LDK", "") + "(null, ")
+            out_java_struct.write("bindings." + re_match.group(2) + "(")
+            for idx, info in enumerate(arg_names):
+                if idx != 0:
+                    out_java_struct.write(", ")
+                if info.arg_name == "this_arg":
+                    out_java_struct.write("this.ptr")
+                elif info.arg_name in default_constructor_args:
+                    out_java_struct.write("bindings." + info.rust_obj.replace("LDK", "") + "_new(")
+                    for explode_idx, explode_arg in enumerate(default_constructor_args[info.arg_name]):
+                        if explode_idx != 0:
+                            out_java_struct.write(", ")
+                        assert explode_arg.passed_as_ptr and explode_arg.rust_obj in trait_structs
+                        expl_arg_name = info.arg_name + "_" + explode_arg.arg_name
+                        out_java_struct.write(expl_arg_name + " == null ? 0 : " + expl_arg_name + ".ptr")
+                    out_java_struct.write(")")
+                elif info.passed_as_ptr and info.rust_obj in opaque_structs:
+                    out_java_struct.write(info.arg_name + " == null ? 0 : " + info.arg_name + ".ptr & ~1")
+                elif info.passed_as_ptr and info.rust_obj in trait_structs:
+                    out_java_struct.write(info.arg_name + " == null ? 0 : " + info.arg_name + ".ptr")
+                else:
+                    out_java_struct.write(info.arg_name)
+            out_java_struct.write(")")
+            if ret_info.rust_obj == "LDK" + struct_meth:
+                out_java_struct.write(");\n")
+            elif ret_info.rust_obj in opaque_structs:
+                out_java_struct.write(");\n")
+            elif ret_info.rust_obj in trait_structs:
+                out_java_struct.write(");\n\t\tret.ptrs_to.add(this);\n")
+            else:
+                out_java_struct.write(";\n")
+
+            for info in arg_names:
+                if info.arg_name == "this_arg":
+                    pass
+                elif info.arg_name in default_constructor_args:
+                    for explode_arg in default_constructor_args[info.arg_name]:
+                        out_java_struct.write("\t\tthis.ptrs_to.add(" + info.arg_name + "_" + explode_arg.arg_name + ");\n")
+                elif info.passed_as_ptr and (info.rust_obj in opaque_structs or info.rust_obj in trait_structs):
+                    out_java_struct.write("\t\tthis.ptrs_to.add(" + info.arg_name + ");\n")
+
+            if ret_info.java_ty != "void" and ret_info.rust_obj != "LDK" + struct_meth:
+                out_java_struct.write("\t\treturn ret;\n")
+            out_java_struct.write("\t}\n\n")
+            out_java_struct.close()

 
     def map_unitary_enum(struct_name, field_lines):
 
     def map_unitary_enum(struct_name, field_lines):

-        with open(sys.argv[3] + "/" + struct_name + ".java", "w") as out_java_enum:
+        with open(sys.argv[3] + "/enums/" + struct_name + ".java", "w") as out_java_enum:

             out_java_enum.write("package org.ldk.enums;\n\n")
             unitary_enums.add(struct_name)
             out_c.write("static inline " + struct_name + " " + struct_name + "_from_java(JNIEnv *env, jclass val) {\n")
             out_java_enum.write("package org.ldk.enums;\n\n")
             unitary_enums.add(struct_name)
             out_c.write("static inline " + struct_name + " " + struct_name + "_from_java(JNIEnv *env, jclass val) {\n")


@@ -411,12 +603,12 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg
                     out_c.write("static jfieldID " + struct_name + "_" + variant + " = NULL;\n")
             out_c.write("JNIEXPORT void JNICALL Java_org_ldk_enums_" + struct_name.replace("_", "_1") + "_init (JNIEnv * env, jclass clz) {\n")
             out_c.write("\t" + struct_name + "_class = (*env)->NewGlobalRef(env, clz);\n")
                     out_c.write("static jfieldID " + struct_name + "_" + variant + " = NULL;\n")
             out_c.write("JNIEXPORT void JNICALL Java_org_ldk_enums_" + struct_name.replace("_", "_1") + "_init (JNIEnv * env, jclass clz) {\n")
             out_c.write("\t" + struct_name + "_class = (*env)->NewGlobalRef(env, clz);\n")

-            out_c.write("\tDO_ASSERT(" + struct_name + "_class != NULL);\n")
+            out_c.write("\tCHECK(" + struct_name + "_class != NULL);\n")

             for idx, struct_line in enumerate(field_lines):
                 if idx > 0 and idx < len(field_lines) - 3:
                     variant = struct_line.strip().strip(",")
                     out_c.write("\t" + struct_name + "_" + variant + " = (*env)->GetStaticFieldID(env, " + struct_name + "_class, \"" + variant + "\", \"Lorg/ldk/enums/" + struct_name + ";\");\n")
             for idx, struct_line in enumerate(field_lines):
                 if idx > 0 and idx < len(field_lines) - 3:
                     variant = struct_line.strip().strip(",")
                     out_c.write("\t" + struct_name + "_" + variant + " = (*env)->GetStaticFieldID(env, " + struct_name + "_class, \"" + variant + "\", \"Lorg/ldk/enums/" + struct_name + ";\");\n")

-                    out_c.write("\tDO_ASSERT(" + struct_name + "_" + variant + " != NULL);\n")
+                    out_c.write("\tCHECK(" + struct_name + "_" + variant + " != NULL);\n")

             out_c.write("}\n")
             out_c.write("static inline jclass " + struct_name + "_to_java(JNIEnv *env, " + struct_name + " val) {\n")
             out_c.write("\tswitch (val) {\n")
             out_c.write("}\n")
             out_c.write("static inline jclass " + struct_name + "_to_java(JNIEnv *env, " + struct_name + " val) {\n")
             out_c.write("\tswitch (val) {\n")


@@ -477,9 +669,9 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg
                 var_name = struct_line.strip(' ,')[len(struct_name) + 1:]
                 out_c.write("\t" + struct_name + "_" + var_name + "_class =\n")
                 out_c.write("\t\t(*env)->NewGlobalRef(env, (*env)->FindClass(env, \"Lorg/ldk/impl/bindings$" + struct_name + "$" + var_name + ";\"));\n")
                 var_name = struct_line.strip(' ,')[len(struct_name) + 1:]
                 out_c.write("\t" + struct_name + "_" + var_name + "_class =\n")
                 out_c.write("\t\t(*env)->NewGlobalRef(env, (*env)->FindClass(env, \"Lorg/ldk/impl/bindings$" + struct_name + "$" + var_name + ";\"));\n")

-                out_c.write("\tDO_ASSERT(" + struct_name + "_" + var_name + "_class != NULL);\n")
+                out_c.write("\tCHECK(" + struct_name + "_" + var_name + "_class != NULL);\n")

                 out_c.write("\t" + struct_name + "_" + var_name + "_meth = (*env)->GetMethodID(env, " + struct_name + "_" + var_name + "_class, \"<init>\", \"(" + init_meth_jty_strs[var_name] + ")V\");\n")
                 out_c.write("\t" + struct_name + "_" + var_name + "_meth = (*env)->GetMethodID(env, " + struct_name + "_" + var_name + "_class, \"<init>\", \"(" + init_meth_jty_strs[var_name] + ")V\");\n")

-                out_c.write("\tDO_ASSERT(" + struct_name + "_" + var_name + "_meth != NULL);\n")
+                out_c.write("\tCHECK(" + struct_name + "_" + var_name + "_meth != NULL);\n")

         out_c.write("}\n")
         out_c.write("JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_" + struct_name.replace("_", "_1") + "_1ref_1from_1ptr (JNIEnv * env, jclass _c, jlong ptr) {\n")
         out_c.write("\t" + struct_name + " *obj = (" + struct_name + "*)ptr;\n")
         out_c.write("}\n")
         out_c.write("JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_" + struct_name.replace("_", "_1") + "_1ref_1from_1ptr (JNIEnv * env, jclass _c, jlong ptr) {\n")
         out_c.write("\t" + struct_name + " *obj = (" + struct_name + "*)ptr;\n")


@@ -507,169 +699,197 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg
         out_c.write("\t}\n}\n")
 
     def map_trait(struct_name, field_var_lines, trait_fn_lines):
         out_c.write("\t}\n}\n")
 
     def map_trait(struct_name, field_var_lines, trait_fn_lines):

-        out_c.write("typedef struct " + struct_name + "_JCalls {\n")
-        out_c.write("\tatomic_size_t refcnt;\n")
-        out_c.write("\tJavaVM *vm;\n")
-        out_c.write("\tjobject o;\n")
-        for var_line in field_var_lines:
-            if var_line.group(1) in trait_structs:
-                out_c.write("\t" + var_line.group(1) + "_JCalls* " + var_line.group(2) + ";\n")
-        for fn_line in trait_fn_lines:
-            if fn_line.group(2) != "free" and fn_line.group(2) != "clone":
-                out_c.write("\tjmethodID " + fn_line.group(2) + "_meth;\n")
-        out_c.write("} " + struct_name + "_JCalls;\n")
-
-        out_java.write("\tpublic interface " + struct_name + " {\n")
-        java_meths = []
-        for fn_line in trait_fn_lines:
-            java_meth_descr = "("
-            if fn_line.group(2) != "free" and fn_line.group(2) != "clone":
-                ret_ty_info = java_c_types(fn_line.group(1), None)
-
-                out_java.write("\t\t " + ret_ty_info.java_ty + " " + fn_line.group(2) + "(")
-                is_const = fn_line.group(3) is not None
-                out_c.write(fn_line.group(1) + fn_line.group(2) + "_jcall(")
-                if is_const:
-                    out_c.write("const void* this_arg")
-                else:
-                    out_c.write("void* this_arg")
-
-                arg_names = []
-                for idx, arg in enumerate(fn_line.group(4).split(',')):
-                    if arg == "":
-                        continue
-                    if idx >= 2:
-                        out_java.write(", ")
-                    out_c.write(", ")
-                    arg_conv_info = map_type(arg, True, None, False)
-                    out_c.write(arg.strip())
-                    out_java.write(arg_conv_info.java_ty + " " + arg_conv_info.arg_name)
-                    arg_names.append(arg_conv_info)
-                    java_meth_descr = java_meth_descr + arg_conv_info.java_fn_ty_arg
-                java_meth_descr = java_meth_descr + ")" + ret_ty_info.java_fn_ty_arg
-                java_meths.append(java_meth_descr)
-
-                out_java.write(");\n")
-                out_c.write(") {\n")
-                out_c.write("\t" + struct_name + "_JCalls *j_calls = (" + struct_name + "_JCalls*) this_arg;\n")
-                out_c.write("\tJNIEnv *env;\n")
-                out_c.write("\tDO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_8) == JNI_OK);\n")
-
-                for arg_info in arg_names:
-                    if arg_info.ret_conv is not None:
-                        out_c.write("\t" + arg_info.ret_conv[0].replace('\n', '\n\t').replace("_env", "env"));
-                        out_c.write(arg_info.arg_name)
-                        out_c.write(arg_info.ret_conv[1].replace('\n', '\n\t').replace("_env", "env") + "\n")
-
-                if ret_ty_info.c_ty.endswith("Array"):
-                    assert(ret_ty_info.c_ty == "jbyteArray")
-                    out_c.write("\tjbyteArray jret = (*env)->CallObjectMethod(env, j_calls->o, j_calls->" + fn_line.group(2) + "_meth")
-                elif not ret_ty_info.passed_as_ptr:
-                    out_c.write("\treturn (*env)->Call" + ret_ty_info.java_ty.title() + "Method(env, j_calls->o, j_calls->" + fn_line.group(2) + "_meth")
-                else:
-                    out_c.write("\t" + fn_line.group(1).strip() + "* ret = (" + fn_line.group(1).strip() + "*)(*env)->CallLongMethod(env, j_calls->o, j_calls->" + fn_line.group(2) + "_meth");
+        with open(sys.argv[3] + "/structs/" + struct_name.replace("LDK","") + ".java", "w") as out_java_trait:
+            out_c.write("typedef struct " + struct_name + "_JCalls {\n")
+            out_c.write("\tatomic_size_t refcnt;\n")
+            out_c.write("\tJavaVM *vm;\n")
+            out_c.write("\tjweak o;\n")
+            for var_line in field_var_lines:
+                if var_line.group(1) in trait_structs:
+                    out_c.write("\t" + var_line.group(1) + "_JCalls* " + var_line.group(2) + ";\n")
+            for fn_line in trait_fn_lines:
+                if fn_line.group(2) != "free" and fn_line.group(2) != "clone":
+                    out_c.write("\tjmethodID " + fn_line.group(2) + "_meth;\n")
+            out_c.write("} " + struct_name + "_JCalls;\n")
+
+            out_java_trait.write("package org.ldk.structs;\n\n")
+            out_java_trait.write("import org.ldk.impl.bindings;\n\n")
+            out_java_trait.write("import org.ldk.enums.*;\n\n")
+            out_java_trait.write("public class " + struct_name.replace("LDK","") + " extends CommonBase {\n")
+            out_java_trait.write("\t" + struct_name.replace("LDK", "") + "(Object _dummy, long ptr) { super(ptr); }\n")
+            out_java_trait.write("\tpublic " + struct_name.replace("LDK", "") + "(bindings." + struct_name + " arg")
+            for var_line in field_var_lines:
+                if var_line.group(1) in trait_structs:
+                    out_java_trait.write(", bindings." + var_line.group(1) + " " + var_line.group(2))
+            out_java_trait.write(") {\n")
+            out_java_trait.write("\t\tsuper(bindings." + struct_name + "_new(arg")
+            for var_line in field_var_lines:
+                if var_line.group(1) in trait_structs:
+                    out_java_trait.write(", " + var_line.group(2))
+            out_java_trait.write("));\n")
+            out_java_trait.write("\t\tthis.ptrs_to.add(arg);\n")
+            out_java_trait.write("\t}\n")
+            out_java_trait.write("\t@Override @SuppressWarnings(\"deprecation\")\n")
+            out_java_trait.write("\tprotected void finalize() throws Throwable {\n")
+            out_java_trait.write("\t\tbindings." + struct_name.replace("LDK","") + "_free(ptr); super.finalize();\n")
+            out_java_trait.write("\t}\n\n")
+
+            out_java.write("\tpublic interface " + struct_name + " {\n")
+            java_meths = []
+            for fn_line in trait_fn_lines:
+                java_meth_descr = "("
+                if fn_line.group(2) != "free" and fn_line.group(2) != "clone":
+                    ret_ty_info = java_c_types(fn_line.group(1), None)
+
+                    out_java.write("\t\t " + ret_ty_info.java_ty + " " + fn_line.group(2) + "(")
+                    is_const = fn_line.group(3) is not None
+                    out_c.write(fn_line.group(1) + fn_line.group(2) + "_jcall(")
+                    if is_const:
+                        out_c.write("const void* this_arg")
+                    else:
+                        out_c.write("void* this_arg")
+
+                    arg_names = []
+                    for idx, arg in enumerate(fn_line.group(4).split(',')):
+                        if arg == "":
+                            continue
+                        if idx >= 2:
+                            out_java.write(", ")
+                        out_c.write(", ")
+                        arg_conv_info = map_type(arg, True, None, False)
+                        out_c.write(arg.strip())
+                        out_java.write(arg_conv_info.java_ty + " " + arg_conv_info.arg_name)
+                        arg_names.append(arg_conv_info)
+                        java_meth_descr = java_meth_descr + arg_conv_info.java_fn_ty_arg
+                    java_meth_descr = java_meth_descr + ")" + ret_ty_info.java_fn_ty_arg
+                    java_meths.append(java_meth_descr)

 
 

-                for arg_info in arg_names:
-                    if arg_info.ret_conv is not None:
-                        out_c.write(", " + arg_info.ret_conv_name)
+                    out_java.write(");\n")
+                    out_c.write(") {\n")
+                    out_c.write("\t" + struct_name + "_JCalls *j_calls = (" + struct_name + "_JCalls*) this_arg;\n")
+                    out_c.write("\tJNIEnv *env;\n")
+                    out_c.write("\tDO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_8) == JNI_OK);\n")
+
+                    for arg_info in arg_names:
+                        if arg_info.ret_conv is not None:
+                            out_c.write("\t" + arg_info.ret_conv[0].replace('\n', '\n\t').replace("_env", "env"));
+                            out_c.write(arg_info.arg_name)
+                            out_c.write(arg_info.ret_conv[1].replace('\n', '\n\t').replace("_env", "env") + "\n")
+
+                    out_c.write("\tjobject obj = (*env)->NewLocalRef(env, j_calls->o);\n\tCHECK(obj != NULL);\n")
+                    if ret_ty_info.c_ty.endswith("Array"):
+                        assert(ret_ty_info.c_ty == "jbyteArray")
+                        out_c.write("\tjbyteArray jret = (*env)->CallObjectMethod(env, obj, j_calls->" + fn_line.group(2) + "_meth")
+                    elif not ret_ty_info.passed_as_ptr:
+                        out_c.write("\treturn (*env)->Call" + ret_ty_info.java_ty.title() + "Method(env, obj, j_calls->" + fn_line.group(2) + "_meth")

                     else:
                     else:

-                        out_c.write(", " + arg_info.arg_name)
-                out_c.write(");\n");
-                if ret_ty_info.c_ty.endswith("Array"):
-                    out_c.write("\t" + ret_ty_info.rust_obj + " ret;\n")
-                    out_c.write("\t(*env)->GetByteArrayRegion(env, jret, 0, " + ret_ty_info.arr_len + ", ret." + ret_ty_info.arr_access + ");\n")
-                    out_c.write("\treturn ret;\n")
-
-                if ret_ty_info.passed_as_ptr:
-                    out_c.write("\t" + fn_line.group(1).strip() + " res = *ret;\n")
-                    out_c.write("\tFREE(ret);\n")
-                    out_c.write("\treturn res;\n")
-                out_c.write("}\n")
-            elif fn_line.group(2) == "free":
-                out_c.write("static void " + struct_name + "_JCalls_free(void* this_arg) {\n")
-                out_c.write("\t" + struct_name + "_JCalls *j_calls = (" + struct_name + "_JCalls*) this_arg;\n")
-                out_c.write("\tif (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {\n")
-                out_c.write("\t\tJNIEnv *env;\n")
-                out_c.write("\t\tDO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_8) == JNI_OK);\n")
-                out_c.write("\t\t(*env)->DeleteGlobalRef(env, j_calls->o);\n")
-                out_c.write("\t\tFREE(j_calls);\n")
-                out_c.write("\t}\n}\n")
-
-        # Write out a clone function whether we need one or not, as we use them in moving to rust
-        out_c.write("static void* " + struct_name + "_JCalls_clone(const void* this_arg) {\n")
-        out_c.write("\t" + struct_name + "_JCalls *j_calls = (" + struct_name + "_JCalls*) this_arg;\n")
-        out_c.write("\tatomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);\n")
-        for var_line in field_var_lines:
-            if var_line.group(1) in trait_structs:
-                out_c.write("\tatomic_fetch_add_explicit(&j_calls->" + var_line.group(2) + "->refcnt, 1, memory_order_release);\n")
-        out_c.write("\treturn (void*) this_arg;\n")
-        out_c.write("}\n")
+                        out_c.write("\t" + fn_line.group(1).strip() + "* ret = (" + fn_line.group(1).strip() + "*)(*env)->CallLongMethod(env, obj, j_calls->" + fn_line.group(2) + "_meth");

 
 

-        out_java.write("\t}\n")
+                    for arg_info in arg_names:
+                        if arg_info.ret_conv is not None:
+                            out_c.write(", " + arg_info.ret_conv_name)
+                        else:
+                            out_c.write(", " + arg_info.arg_name)
+                    out_c.write(");\n");
+                    if ret_ty_info.c_ty.endswith("Array"):
+                        out_c.write("\t" + ret_ty_info.rust_obj + " ret;\n")
+                        out_c.write("\tCHECK((*env)->GetArrayLength(env, jret) == " + ret_ty_info.arr_len + ");\n")
+                        out_c.write("\t(*env)->GetByteArrayRegion(env, jret, 0, " + ret_ty_info.arr_len + ", ret." + ret_ty_info.arr_access + ");\n")
+                        out_c.write("\treturn ret;\n")

 
 

-        out_java.write("\tpublic static native long " + struct_name + "_new(" + struct_name + " impl")
-        out_c.write("static inline " + struct_name + " " + struct_name + "_init (JNIEnv * env, jclass _a, jobject o")
-        for var_line in field_var_lines:
-            if var_line.group(1) in trait_structs:
-                out_java.write(", " + var_line.group(1) + " " + var_line.group(2))
-                out_c.write(", jobject " + var_line.group(2))
-        out_java.write(");\n")
-        out_c.write(") {\n")
+                    if ret_ty_info.passed_as_ptr:
+                        out_c.write("\t" + fn_line.group(1).strip() + " res = *ret;\n")
+                        out_c.write("\tFREE(ret);\n")
+                        out_c.write("\treturn res;\n")
+                    out_c.write("}\n")
+                elif fn_line.group(2) == "free":
+                    out_c.write("static void " + struct_name + "_JCalls_free(void* this_arg) {\n")
+                    out_c.write("\t" + struct_name + "_JCalls *j_calls = (" + struct_name + "_JCalls*) this_arg;\n")
+                    out_c.write("\tif (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {\n")
+                    out_c.write("\t\tJNIEnv *env;\n")
+                    out_c.write("\t\tDO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_8) == JNI_OK);\n")
+                    out_c.write("\t\t(*env)->DeleteWeakGlobalRef(env, j_calls->o);\n")
+                    out_c.write("\t\tFREE(j_calls);\n")
+                    out_c.write("\t}\n}\n")

 
 

-        out_c.write("\tjclass c = (*env)->GetObjectClass(env, o);\n")
-        out_c.write("\tDO_ASSERT(c != NULL);\n")
-        out_c.write("\t" + struct_name + "_JCalls *calls = MALLOC(sizeof(" + struct_name + "_JCalls), \"" + struct_name + "_JCalls\");\n")
-        out_c.write("\tatomic_init(&calls->refcnt, 1);\n")
-        out_c.write("\tDO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);\n")
-        out_c.write("\tcalls->o = (*env)->NewGlobalRef(env, o);\n")
-        for (fn_line, java_meth_descr) in zip(trait_fn_lines, java_meths):
-            if fn_line.group(2) != "free" and fn_line.group(2) != "clone":
-                out_c.write("\tcalls->" + fn_line.group(2) + "_meth = (*env)->GetMethodID(env, c, \"" + fn_line.group(2) + "\", \"" + java_meth_descr + "\");\n")
-                out_c.write("\tDO_ASSERT(calls->" + fn_line.group(2) + "_meth != NULL);\n")
-        out_c.write("\n\t" + struct_name + " ret = {\n")
-        out_c.write("\t\t.this_arg = (void*) calls,\n")
-        for fn_line in trait_fn_lines:
-            if fn_line.group(2) != "free" and fn_line.group(2) != "clone":
-                out_c.write("\t\t." + fn_line.group(2) + " = " + fn_line.group(2) + "_jcall,\n")
-            elif fn_line.group(2) == "free":
-                out_c.write("\t\t.free = " + struct_name + "_JCalls_free,\n")
-            else:
-                out_c.write("\t\t.clone = " + struct_name + "_JCalls_clone,\n")
-        for var_line in field_var_lines:
-            if var_line.group(1) in trait_structs:
-                out_c.write("\t\t." + var_line.group(2) + " = " + var_line.group(1) + "_init(env, _a, " + var_line.group(2) + "),\n")
-        out_c.write("\t};\n")
-        for var_line in field_var_lines:
-            if var_line.group(1) in trait_structs:
-                out_c.write("\tcalls->" + var_line.group(2) + " = ret." + var_line.group(2) + ".this_arg;\n")
-        out_c.write("\treturn ret;\n")
-        out_c.write("}\n")
+            # Write out a clone function whether we need one or not, as we use them in moving to rust
+            out_c.write("static void* " + struct_name + "_JCalls_clone(const void* this_arg) {\n")
+            out_c.write("\t" + struct_name + "_JCalls *j_calls = (" + struct_name + "_JCalls*) this_arg;\n")
+            out_c.write("\tatomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);\n")
+            for var_line in field_var_lines:
+                if var_line.group(1) in trait_structs:
+                    out_c.write("\tatomic_fetch_add_explicit(&j_calls->" + var_line.group(2) + "->refcnt, 1, memory_order_release);\n")
+            out_c.write("\treturn (void*) this_arg;\n")
+            out_c.write("}\n")

 
 

-        out_c.write("JNIEXPORT long JNICALL Java_org_ldk_impl_bindings_" + struct_name.replace("_", "_1") + "_1new (JNIEnv * env, jclass _a, jobject o")
-        for var_line in field_var_lines:
-            if var_line.group(1) in trait_structs:
-                out_c.write(", jobject " + var_line.group(2))
-        out_c.write(") {\n")
-        out_c.write("\t" + struct_name + " *res_ptr = MALLOC(sizeof(" + struct_name + "), \"" + struct_name + "\");\n")
-        out_c.write("\t*res_ptr = " + struct_name + "_init(env, _a, o")
-        for var_line in field_var_lines:
-            if var_line.group(1) in trait_structs:
-                out_c.write(", " + var_line.group(2))
-        out_c.write(");\n")
-        out_c.write("\treturn (long)res_ptr;\n")
-        out_c.write("}\n")
+            out_java.write("\t}\n")
+
+            out_java.write("\tpublic static native long " + struct_name + "_new(" + struct_name + " impl")
+            out_c.write("static inline " + struct_name + " " + struct_name + "_init (JNIEnv * env, jclass _a, jobject o")
+            for var_line in field_var_lines:
+                if var_line.group(1) in trait_structs:
+                    out_java.write(", " + var_line.group(1) + " " + var_line.group(2))
+                    out_c.write(", jobject " + var_line.group(2))
+            out_java.write(");\n")
+            out_c.write(") {\n")
+
+            out_c.write("\tjclass c = (*env)->GetObjectClass(env, o);\n")
+            out_c.write("\tCHECK(c != NULL);\n")
+            out_c.write("\t" + struct_name + "_JCalls *calls = MALLOC(sizeof(" + struct_name + "_JCalls), \"" + struct_name + "_JCalls\");\n")
+            out_c.write("\tatomic_init(&calls->refcnt, 1);\n")
+            out_c.write("\tDO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);\n")
+            out_c.write("\tcalls->o = (*env)->NewWeakGlobalRef(env, o);\n")
+            for (fn_line, java_meth_descr) in zip(trait_fn_lines, java_meths):
+                if fn_line.group(2) != "free" and fn_line.group(2) != "clone":
+                    out_c.write("\tcalls->" + fn_line.group(2) + "_meth = (*env)->GetMethodID(env, c, \"" + fn_line.group(2) + "\", \"" + java_meth_descr + "\");\n")
+                    out_c.write("\tCHECK(calls->" + fn_line.group(2) + "_meth != NULL);\n")
+            out_c.write("\n\t" + struct_name + " ret = {\n")
+            out_c.write("\t\t.this_arg = (void*) calls,\n")
+            for fn_line in trait_fn_lines:
+                if fn_line.group(2) != "free" and fn_line.group(2) != "clone":
+                    out_c.write("\t\t." + fn_line.group(2) + " = " + fn_line.group(2) + "_jcall,\n")
+                elif fn_line.group(2) == "free":
+                    out_c.write("\t\t.free = " + struct_name + "_JCalls_free,\n")
+                else:
+                    clone_fns.add(struct_name + "_clone")
+                    out_c.write("\t\t.clone = " + struct_name + "_JCalls_clone,\n")
+            for var_line in field_var_lines:
+                if var_line.group(1) in trait_structs:
+                    out_c.write("\t\t." + var_line.group(2) + " = " + var_line.group(1) + "_init(env, _a, " + var_line.group(2) + "),\n")
+            out_c.write("\t};\n")
+            for var_line in field_var_lines:
+                if var_line.group(1) in trait_structs:
+                    out_c.write("\tcalls->" + var_line.group(2) + " = ret." + var_line.group(2) + ".this_arg;\n")
+            out_c.write("\treturn ret;\n")
+            out_c.write("}\n")

 
 

-        out_java.write("\tpublic static native " + struct_name + " " + struct_name + "_get_obj_from_jcalls(long val);\n")
-        out_c.write("JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_" + struct_name.replace("_", "_1") + "_1get_1obj_1from_1jcalls (JNIEnv * env, jclass _a, jlong val) {\n")
-        out_c.write("\treturn ((" + struct_name + "_JCalls*)val)->o;\n")
-        out_c.write("}\n")
+            out_c.write("JNIEXPORT long JNICALL Java_org_ldk_impl_bindings_" + struct_name.replace("_", "_1") + "_1new (JNIEnv * env, jclass _a, jobject o")
+            for var_line in field_var_lines:
+                if var_line.group(1) in trait_structs:
+                    out_c.write(", jobject " + var_line.group(2))
+            out_c.write(") {\n")
+            out_c.write("\t" + struct_name + " *res_ptr = MALLOC(sizeof(" + struct_name + "), \"" + struct_name + "\");\n")
+            out_c.write("\t*res_ptr = " + struct_name + "_init(env, _a, o")
+            for var_line in field_var_lines:
+                if var_line.group(1) in trait_structs:
+                    out_c.write(", " + var_line.group(2))
+            out_c.write(");\n")
+            out_c.write("\treturn (long)res_ptr;\n")
+            out_c.write("}\n")
+
+            out_java.write("\tpublic static native " + struct_name + " " + struct_name + "_get_obj_from_jcalls(long val);\n")
+            out_c.write("JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_" + struct_name.replace("_", "_1") + "_1get_1obj_1from_1jcalls (JNIEnv * env, jclass _a, jlong val) {\n")
+            out_c.write("\tjobject ret = (*env)->NewLocalRef(env, ((" + struct_name + "_JCalls*)val)->o);\n")
+            out_c.write("\tCHECK(ret != NULL);\n")
+            out_c.write("\treturn ret;\n")
+            out_c.write("}\n")

 
         for fn_line in trait_fn_lines:
             # For now, just disable enabling the _call_log - we don't know how to inverse-map String
             is_log = fn_line.group(2) == "log" and struct_name == "LDKLogger"
             if fn_line.group(2) != "free" and fn_line.group(2) != "clone" and fn_line.group(2) != "eq" and not is_log:
 
         for fn_line in trait_fn_lines:
             # For now, just disable enabling the _call_log - we don't know how to inverse-map String
             is_log = fn_line.group(2) == "log" and struct_name == "LDKLogger"
             if fn_line.group(2) != "free" and fn_line.group(2) != "clone" and fn_line.group(2) != "eq" and not is_log:

-                dummy_line = fn_line.group(1) + struct_name + "_call_" + fn_line.group(2) + " " + struct_name + "* arg" + fn_line.group(4) + "\n"
-                map_fn(dummy_line, re.compile("([A-Za-z_0-9]*) *([A-Za-z_0-9]*) *(.*)").match(dummy_line), None, "(arg_conv->" + fn_line.group(2) + ")(arg_conv->this_arg")
+                dummy_line = fn_line.group(1) + struct_name.replace("LDK", "") + "_" + fn_line.group(2) + " " + struct_name + "* this_arg" + fn_line.group(4) + "\n"
+                map_fn(dummy_line, re.compile("([A-Za-z_0-9]*) *([A-Za-z_0-9]*) *(.*)").match(dummy_line), None, "(this_arg_conv->" + fn_line.group(2) + ")(this_arg_conv->this_arg")

 
     out_c.write("""#include \"org_ldk_impl_bindings.h\"
 #include <rust_types.h>
 
     out_c.write("""#include \"org_ldk_impl_bindings.h\"
 #include <rust_types.h>


@@ -682,9 +902,13 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg
         out_c.write("#define MALLOC(a, _) malloc(a)\n")
         out_c.write("#define FREE free\n")
         out_c.write("#define DO_ASSERT(a) (void)(a)\n")
         out_c.write("#define MALLOC(a, _) malloc(a)\n")
         out_c.write("#define FREE free\n")
         out_c.write("#define DO_ASSERT(a) (void)(a)\n")

+        out_c.write("#define CHECK(a)\n")

     else:
         out_c.write("""#include <assert.h>
     else:
         out_c.write("""#include <assert.h>

+// Always run a, then assert it is true:

 #define DO_ASSERT(a) do { bool _assert_val = (a); assert(_assert_val); } while(0)
 #define DO_ASSERT(a) do { bool _assert_val = (a); assert(_assert_val); } while(0)

+// Assert a is true or do nothing
+#define CHECK(a) DO_ASSERT(a)

 
 // Running a leak check across all the allocations and frees of the JDK is a mess,
 // so instead we implement our own naive leak checker here, relying on the -wrap
 
 // Running a leak check across all the allocations and frees of the JDK is a mess,
 // so instead we implement our own naive leak checker here, relying on the -wrap


@@ -813,11 +1037,11 @@ static jmethodID slicedef_meth = NULL;
 static jclass slicedef_cls = NULL;
 JNIEXPORT void Java_org_ldk_impl_bindings_init(JNIEnv * env, jclass _b, jclass enum_class, jclass slicedef_class) {
        ordinal_meth = (*env)->GetMethodID(env, enum_class, "ordinal", "()I");
 static jclass slicedef_cls = NULL;
 JNIEXPORT void Java_org_ldk_impl_bindings_init(JNIEnv * env, jclass _b, jclass enum_class, jclass slicedef_class) {
        ordinal_meth = (*env)->GetMethodID(env, enum_class, "ordinal", "()I");

-       DO_ASSERT(ordinal_meth != NULL);
+       CHECK(ordinal_meth != NULL);

        slicedef_meth = (*env)->GetMethodID(env, slicedef_class, "<init>", "(JJJ)V");
        slicedef_meth = (*env)->GetMethodID(env, slicedef_class, "<init>", "(JJJ)V");

-       DO_ASSERT(slicedef_meth != NULL);
+       CHECK(slicedef_meth != NULL);

        slicedef_cls = (*env)->NewGlobalRef(env, slicedef_class);
        slicedef_cls = (*env)->NewGlobalRef(env, slicedef_class);

-       DO_ASSERT(slicedef_cls != NULL);
+       CHECK(slicedef_cls != NULL);

 }
 
 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_deref_1bool (JNIEnv * env, jclass _a, jlong ptr) {
 }
 
 JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_deref_1bool (JNIEnv * env, jclass _a, jlong ptr) {


@@ -883,19 +1107,20 @@ _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKu8slice, datalen),
 
 """)
 
 
 """)
 

-    # XXX: Temporarily write out a manual SecretKey_new() for testing, we should auto-gen this kind of thing
-    out_java.write("\tpublic static native long LDKSecretKey_new();\n\n") # TODO: rm me
-    out_c.write("JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKSecretKey_1new(JNIEnv * _env, jclass _b) {\n") # TODO: rm me
-    out_c.write("\tLDKSecretKey* key = (LDKSecretKey*)MALLOC(sizeof(LDKSecretKey), \"LDKSecretKey\");\n") # TODO: rm me
-    out_c.write("\treturn (long)key;\n") # TODO: rm me
-    out_c.write("}\n") # TODO: rm me
+    with open(sys.argv[3] + "/structs/CommonBase.java", "a") as out_java_struct:
+        out_java_struct.write("""package org.ldk.structs;
+import java.util.LinkedList;
+class CommonBase {
+       final long ptr;
+       LinkedList<Object> ptrs_to = new LinkedList();
+       protected CommonBase(long ptr) { this.ptr = ptr; }
+       public long _test_only_get_ptr() { return this.ptr; }
+}
+""")

 
     in_block_comment = False
     cur_block_obj = None
 
 
     in_block_comment = False
     cur_block_obj = None
 

-    fn_ptr_regex = re.compile("^extern const ([A-Za-z_0-9\* ]*) \(\*(.*)\)\((.*)\);$")
-    fn_ret_arr_regex = re.compile("(.*) \(\*(.*)\((.*)\)\)\[([0-9]*)\];$")
-    reg_fn_regex = re.compile("([A-Za-z_0-9\* ]* \*?)([a-zA-Z_0-9]*)\((.*)\);$")

     const_val_regex = re.compile("^extern const ([A-Za-z_0-9]*) ([A-Za-z_0-9]*);$")
 
     line_indicates_result_regex = re.compile("^   (LDKCResultPtr_[A-Za-z_0-9]*) contents;$")
     const_val_regex = re.compile("^extern const ([A-Za-z_0-9]*) ([A-Za-z_0-9]*);$")
 
     line_indicates_result_regex = re.compile("^   (LDKCResultPtr_[A-Za-z_0-9]*) contents;$")


@@ -982,6 +1207,16 @@ _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKu8slice, datalen),
 
                 if is_opaque:
                     opaque_structs.add(struct_name)
 
                 if is_opaque:
                     opaque_structs.add(struct_name)

+                    with open(sys.argv[3] + "/structs/" + struct_name.replace("LDK","") + ".java", "w") as out_java_struct:
+                        out_java_struct.write("package org.ldk.structs;\n\n")
+                        out_java_struct.write("import org.ldk.impl.bindings;\n")
+                        out_java_struct.write("import org.ldk.enums.*;\n\n")
+                        out_java_struct.write("public class " + struct_name.replace("LDK","") + " extends CommonBase {\n")
+                        out_java_struct.write("\t" + struct_name.replace("LDK", "") + "(Object _dummy, long ptr) { super(ptr); }\n")
+                        out_java_struct.write("\t@Override @SuppressWarnings(\"deprecation\")\n")
+                        out_java_struct.write("\tprotected void finalize() throws Throwable {\n")
+                        out_java_struct.write("\t\tbindings." + struct_name.replace("LDK","") + "_free(ptr); super.finalize();\n")
+                        out_java_struct.write("\t}\n\n")

                 elif result_contents is not None:
                     result_templ_structs.add(struct_name)
                     assert result_contents in result_ptr_struct_items
                 elif result_contents is not None:
                     result_templ_structs.add(struct_name)
                     assert result_contents in result_ptr_struct_items


@@ -1015,6 +1250,7 @@ _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKu8slice, datalen),
                                 out_c.write("\n\tret->" + e + " = " + ty_info.arg_conv_name + ";\n")
                             else:
                                 out_c.write("\tret->" + e + " = " + e + ";\n")
                                 out_c.write("\n\tret->" + e + " = " + ty_info.arg_conv_name + ";\n")
                             else:
                                 out_c.write("\tret->" + e + " = " + e + ";\n")

+                            assert ty_info.arg_conv_cleanup is None

                     out_c.write("\treturn (long)ret;\n")
                     out_c.write("}\n")
                 elif vec_ty is not None:
                     out_c.write("\treturn (long)ret;\n")
                     out_c.write("}\n")
                 elif vec_ty is not None:


@@ -1029,7 +1265,7 @@ _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKu8slice, datalen),
                         out_c.write("\tjlongArray ret = (*env)->NewLongArray(env, vec->datalen);\n")
                         out_c.write("\tjlong *ret_elems = (*env)->GetPrimitiveArrayCritical(env, ret, NULL);\n")
                         out_c.write("\tfor (size_t i = 0; i < vec->datalen; i++) {\n")
                         out_c.write("\tjlongArray ret = (*env)->NewLongArray(env, vec->datalen);\n")
                         out_c.write("\tjlong *ret_elems = (*env)->GetPrimitiveArrayCritical(env, ret, NULL);\n")
                         out_c.write("\tfor (size_t i = 0; i < vec->datalen; i++) {\n")

-                        out_c.write("\t\tDO_ASSERT((((long)vec->data[i].inner) & 1) == 0);\n")
+                        out_c.write("\t\tCHECK((((long)vec->data[i].inner) & 1) == 0);\n")

                         out_c.write("\t\tret_elems[i] = (long)vec->data[i].inner | (vec->data[i].is_owned ? 1 : 0);\n")
                         out_c.write("\t}\n")
                         out_c.write("\t(*env)->ReleasePrimitiveArrayCritical(env, ret, ret_elems, 0);\n")
                         out_c.write("\t\tret_elems[i] = (long)vec->data[i].inner | (vec->data[i].is_owned ? 1 : 0);\n")
                         out_c.write("\t}\n")
                         out_c.write("\t(*env)->ReleasePrimitiveArrayCritical(env, ret, ret_elems, 0);\n")


@@ -1054,6 +1290,7 @@ _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKu8slice, datalen),
                             out_c.write("\t\t\t" + ty_info.c_ty + " arr_elem = java_elems[i];\n")
                             out_c.write("\t\t\t" + ty_info.arg_conv.replace("\n", "\n\t\t\t") + "\n")
                             out_c.write("\t\t\tret->data[i] = " + ty_info.arg_conv_name + ";\n")
                             out_c.write("\t\t\t" + ty_info.c_ty + " arr_elem = java_elems[i];\n")
                             out_c.write("\t\t\t" + ty_info.arg_conv.replace("\n", "\n\t\t\t") + "\n")
                             out_c.write("\t\t\tret->data[i] = " + ty_info.arg_conv_name + ";\n")

+                            assert ty_info.arg_conv_cleanup is None

                         else:
                             out_c.write("\t\t\tret->data[i] = java_elems[i];\n")
                         out_c.write("\t\t}\n")
                         else:
                             out_c.write("\t\t\tret->data[i] = java_elems[i];\n")
                         out_c.write("\t\t}\n")


@@ -1131,3 +1368,9 @@ _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKu8slice, datalen),
                 assert(line == "\n")
 
     out_java.write("}\n")
                 assert(line == "\n")
 
     out_java.write("}\n")

+    for struct_name in opaque_structs:
+        with open(sys.argv[3] + "/structs/" + struct_name.replace("LDK","") + ".java", "a") as out_java_struct:
+            out_java_struct.write("}\n")
+    for struct_name in trait_structs:
+        with open(sys.argv[3] + "/structs/" + struct_name.replace("LDK","") + ".java", "a") as out_java_struct:
+            out_java_struct.write("}\n")