[C#] Update test to LDK 0.0.123 and pay a BOLT12 offer

[ldk-java] / genbindings.py

diff --git a/genbindings.py b/genbindings.py
index 77f9b472f7864383c2780524fb722f16982415cf..9ae48c4e234dae675047412f5508fd4ccd39e5d5 100755 (executable)
--- a/genbindings.py
+++ b/genbindings.py
@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
 import os, sys, re, subprocess
 
 #!/usr/bin/env python3
 import os, sys, re, subprocess
 

-if len(sys.argv) < 7:
-    print("USAGE: /path/to/lightning.h /path/to/bindings/output /path/to/bindings/ /path/to/bindings/output.c debug lang")
+if len(sys.argv) < 8:
+    print("USAGE: /path/to/lightning.h /path/to/bindings/output /path/to/bindings/ /path/to/bindings/output.c debug lang target-tuple")

     sys.exit(1)
 
 if sys.argv[5] == "false":
     sys.exit(1)
 
 if sys.argv[5] == "false":


@@ -20,21 +20,33 @@ if sys.argv[6] == "java" or sys.argv[6] == "android":
     target = java_strings.Target.JAVA
     if sys.argv[6] == "android":
         target = java_strings.Target.ANDROID
     target = java_strings.Target.JAVA
     if sys.argv[6] == "android":
         target = java_strings.Target.ANDROID

+    if "apple" in sys.argv[8]:
+        target = java_strings.Target.MACOS

 elif sys.argv[6] == "typescript":
     import typescript_strings
     from typescript_strings import Consts
     target = typescript_strings.Target.NODEJS
     if len(sys.argv) == 8 and sys.argv[7] == 'browser':
         target = typescript_strings.Target.BROWSER
 elif sys.argv[6] == "typescript":
     import typescript_strings
     from typescript_strings import Consts
     target = typescript_strings.Target.NODEJS
     if len(sys.argv) == 8 and sys.argv[7] == 'browser':
         target = typescript_strings.Target.BROWSER

-elif sys.argv[6] == "c_sharp":
+elif sys.argv[6].startswith("c_sharp"):

     import csharp_strings
     from csharp_strings import Consts
     import csharp_strings
     from csharp_strings import Consts

-    target = csharp_strings.Target.CSHARP
+    if sys.argv[6] == "c_sharp-win":
+        target = csharp_strings.Target.WINDOWS
+    elif sys.argv[6] == "c_sharp-darwin":
+        target = csharp_strings.Target.PTHREAD
+    elif sys.argv[6] == "c_sharp-linux":
+        target = csharp_strings.Target.LINUX
+    else:
+        assert False
+elif sys.argv[6] == "python":
+    import python_strings
+    from python_strings import Consts
+    target = python_strings.Target.PYTHON

 else:
 else:

-    print("Only java, typescript, or c_sharp can be set for lang")
+    print("Only java, typescript, python, or c_sharp can be set for lang")

     sys.exit(1)
 
     sys.exit(1)
 

-

 consts = Consts(DEBUG, target=target, outdir=sys.argv[4])
 
 local_git_version = os.getenv("LDK_GARBAGECOLLECTED_GIT_OVERRIDE")
 consts = Consts(DEBUG, target=target, outdir=sys.argv[4])
 
 local_git_version = os.getenv("LDK_GARBAGECOLLECTED_GIT_OVERRIDE")


@@ -128,25 +140,15 @@ def java_c_types(fn_arg, ret_arr_len):
     rust_obj = None
     arr_access = None
     java_hu_ty = None
     rust_obj = None
     arr_access = None
     java_hu_ty = None

-    if fn_arg.startswith("LDKPaymentPreimage") or fn_arg.startswith("LDKPaymentSecret") or fn_arg.startswith("LDKPaymentHash"):
-        if fn_arg.startswith("LDKPaymentPreimage"):
-            fn_arg = "uint8_t (*" + fn_arg[19:] + ")[32]"
-        elif fn_arg.startswith("LDKPaymentSecret"):
-            fn_arg = "uint8_t (*" + fn_arg[17:] + ")[32]"
-        elif fn_arg.startswith("LDKPaymentHash"):
-            fn_arg = "uint8_t (*" + fn_arg[15:] + ")[32]"
-        assert var_is_arr_regex.match(fn_arg[8:])
-        rust_obj = "LDKThirtyTwoBytes"
-        arr_access = "data"
-    elif fn_arg.startswith("LDKThirtyTwoBytes"):
+    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"
         fn_arg = "uint8_t (*" + fn_arg[18:] + ")[32]"
         assert var_is_arr_regex.match(fn_arg[8:])
         rust_obj = "LDKThirtyTwoBytes"
         arr_access = "data"

-    elif fn_arg.startswith("LDKEightU16s"):
-        fn_arg = "uint16_t (*" + fn_arg[13:] + ")[8]"
+    elif fn_arg.startswith("LDKThirtyTwoU16s"):
+        fn_arg = "uint16_t (*" + fn_arg[17:] + ")[32]"

         assert var_is_arr_regex.match(fn_arg[9:])
         assert var_is_arr_regex.match(fn_arg[9:])

-        rust_obj = "LDKEightU16s"
+        rust_obj = "LDKThirtyTwoU16s"

         arr_access = "data"
     elif fn_arg.startswith("LDKU128"):
         if fn_arg == "LDKU128":
         arr_access = "data"
     elif fn_arg.startswith("LDKU128"):
         if fn_arg == "LDKU128":


@@ -158,25 +160,30 @@ def java_c_types(fn_arg, ret_arr_len):
         assert var_is_arr_regex.match(fn_arg[8:])
         rust_obj = "LDKU128"
         arr_access = "le_bytes"
         assert var_is_arr_regex.match(fn_arg[8:])
         rust_obj = "LDKU128"
         arr_access = "le_bytes"

-    elif fn_arg.startswith("LDKTxid"):
-        fn_arg = "uint8_t (*" + fn_arg[8:] + ")[32]"
-        assert var_is_arr_regex.match(fn_arg[8:])
-        rust_obj = "LDKThirtyTwoBytes"
-        arr_access = "data"

     elif 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"
     elif 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"

+    elif fn_arg.startswith("LDKTweakedPublicKey"):
+        fn_arg = "uint8_t (*" + fn_arg[21:] + ")[32]"
+        assert var_is_arr_regex.match(fn_arg[8:])
+        rust_obj = "LDKTweakedPublicKey"
+        arr_access = "x_coordinate"

     elif 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"
     elif 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"

-    elif fn_arg.startswith("LDKSignature"):
-        fn_arg = "uint8_t (*" + fn_arg[13:] + ")[64]"
+    elif fn_arg.startswith("LDKECDSASignature"):
+        fn_arg = "uint8_t (*" + fn_arg[18:] + ")[64]"
+        assert var_is_arr_regex.match(fn_arg[8:])
+        rust_obj = "LDKECDSASignature"
+        arr_access = "compact_form"
+    elif fn_arg.startswith("LDKSchnorrSignature"):
+        fn_arg = "uint8_t (*" + fn_arg[20:] + ")[64]"

         assert var_is_arr_regex.match(fn_arg[8:])
         assert var_is_arr_regex.match(fn_arg[8:])

-        rust_obj = "LDKSignature"
+        rust_obj = "LDKSchnorrSignature"

         arr_access = "compact_form"
     elif fn_arg.startswith("LDKRecoverableSignature"):
         fn_arg = "uint8_t (*" + fn_arg[24:] + ")[68]"
         arr_access = "compact_form"
     elif fn_arg.startswith("LDKRecoverableSignature"):
         fn_arg = "uint8_t (*" + fn_arg[24:] + ")[68]"


@@ -223,8 +230,14 @@ def java_c_types(fn_arg, ret_arr_len):
         rust_obj = "LDKTransaction"
         assert var_is_arr_regex.match(fn_arg[8:])
         arr_access = "data"
         rust_obj = "LDKTransaction"
         assert var_is_arr_regex.match(fn_arg[8:])
         arr_access = "data"

+    elif fn_arg.startswith("LDKTransactionOutputs "):
+        fn_arg = "C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ"
+        rust_obj = "C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ"

     elif fn_arg.startswith("LDKWitness ") or fn_arg == "LDKWitness":
     elif fn_arg.startswith("LDKWitness ") or fn_arg == "LDKWitness":

-        fn_arg = "uint8_t (*" + fn_arg[11:] + ")[datalen]"
+        if len(fn_arg) > 12 and fn_arg[11] == "*":
+            fn_arg = "uint8_t (" + fn_arg[11:] + ")[datalen]"
+        else:
+            fn_arg = "uint8_t (*" + fn_arg[11:] + ")[datalen]"

         rust_obj = "LDKWitness"
         assert var_is_arr_regex.match(fn_arg[8:])
         arr_access = "data"
         rust_obj = "LDKWitness"
         assert var_is_arr_regex.match(fn_arg[8:])
         arr_access = "data"


@@ -316,6 +329,22 @@ def java_c_types(fn_arg, ret_arr_len):
         fn_ty_arg = "I"
         fn_arg = fn_arg[8:].strip()
         is_primitive = True
         fn_ty_arg = "I"
         fn_arg = fn_arg[8:].strip()
         is_primitive = True

+    elif fn_arg.startswith("int64_t"):
+        mapped_type = consts.c_type_map['int64_t']
+        java_ty = mapped_type[0]
+        c_ty = "int64_t"
+        arr_ty = "int64_t"
+        fn_ty_arg = "J"
+        fn_arg = fn_arg[7:].strip()
+        is_primitive = True
+    elif fn_arg.startswith("double"):
+        mapped_type = consts.c_type_map['double']
+        java_ty = mapped_type[0]
+        c_ty = "double"
+        arr_ty = "double"
+        fn_ty_arg = "D"
+        fn_arg = fn_arg[6:].strip()
+        is_primitive = True

     elif fn_arg.startswith("uint64_t") or fn_arg.startswith("uintptr_t"):
         # TODO: uintptr_t is arch-dependent :(
         mapped_type = consts.c_type_map['uint64_t']
     elif fn_arg.startswith("uint64_t") or fn_arg.startswith("uintptr_t"):
         # TODO: uintptr_t is arch-dependent :(
         mapped_type = consts.c_type_map['uint64_t']


@@ -339,14 +368,17 @@ def java_c_types(fn_arg, ret_arr_len):
         arr_ty = "LDKStr"
         fn_ty_arg = "Ljava/lang/String;"
         fn_arg = fn_arg[6:].strip()
         arr_ty = "LDKStr"
         fn_ty_arg = "Ljava/lang/String;"
         fn_arg = fn_arg[6:].strip()

-    elif fn_arg.startswith("LDKStr"):
+    elif fn_arg.startswith("LDKStr") or fn_arg.startswith("LDKAddress"):

         rust_obj = "LDKStr"
         arr_ty = "LDKStr"
         java_ty = consts.java_type_map["String"]
         java_hu_ty = consts.java_hu_type_map["String"]
         c_ty = "jstring"
         fn_ty_arg = "Ljava/lang/String;"
         rust_obj = "LDKStr"
         arr_ty = "LDKStr"
         java_ty = consts.java_type_map["String"]
         java_hu_ty = consts.java_hu_type_map["String"]
         c_ty = "jstring"
         fn_ty_arg = "Ljava/lang/String;"

-        fn_arg = fn_arg[6:].strip()
+        if fn_arg.startswith("LDKAddress"):
+            fn_arg = fn_arg[10:].strip()
+        else:
+            fn_arg = fn_arg[6:].strip()

         arr_access = "chars"
         arr_len = "len"
     elif fn_arg.startswith("LDKError ") or fn_arg == "LDKError":
         arr_access = "chars"
         arr_len = "len"
     elif fn_arg.startswith("LDKError ") or fn_arg == "LDKError":


@@ -364,7 +396,7 @@ def java_c_types(fn_arg, ret_arr_len):
             assert ma.group(1).strip().startswith("LDK")
             java_ty = ma.group(1).strip()[3:]
             java_hu_ty = java_ty
             assert ma.group(1).strip().startswith("LDK")
             java_ty = ma.group(1).strip()[3:]
             java_hu_ty = java_ty

-            c_ty = consts.result_c_ty
+            c_ty = consts.unitary_enum_c_ty

             fn_ty_arg = "Lorg/ldk/enums/" + java_ty + ";"
             fn_arg = ma.group(2).strip()
             rust_obj = ma.group(1).strip()
             fn_ty_arg = "Lorg/ldk/enums/" + java_ty + ";"
             fn_arg = ma.group(2).strip()
             rust_obj = ma.group(1).strip()


@@ -376,6 +408,7 @@ def java_c_types(fn_arg, ret_arr_len):
             java_hu_ty = java_hu_ty.replace("LDKCResult", "Result")
             java_hu_ty = java_hu_ty.replace("LDKC2Tuple", "TwoTuple")
             java_hu_ty = java_hu_ty.replace("LDKC3Tuple", "ThreeTuple")
             java_hu_ty = java_hu_ty.replace("LDKCResult", "Result")
             java_hu_ty = java_hu_ty.replace("LDKC2Tuple", "TwoTuple")
             java_hu_ty = java_hu_ty.replace("LDKC3Tuple", "ThreeTuple")

+            java_hu_ty = java_hu_ty.replace("LDKC4Tuple", "FourTuple")

             java_hu_ty = java_hu_ty.replace("LDK", "")
             fn_ty_arg = "J"
             fn_arg = ma.group(2).strip()
             java_hu_ty = java_hu_ty.replace("LDK", "")
             fn_ty_arg = "J"
             fn_arg = ma.group(2).strip()


@@ -544,14 +577,17 @@ with open(sys.argv[1]) as in_h, open(f"{sys.argv[2]}/bindings{consts.file_ext}",
             struct_meth = method_name.rsplit("Z", 1)[0][1:] + "Z"
             expected_struct = "LDKC" + struct_meth
             struct_meth_name = method_name[len(struct_meth) + 1:].strip("_")
             struct_meth = method_name.rsplit("Z", 1)[0][1:] + "Z"
             expected_struct = "LDKC" + struct_meth
             struct_meth_name = method_name[len(struct_meth) + 1:].strip("_")

-        elif method_name.startswith("C2Tuple") or method_name.startswith("C3Tuple"):
+        elif method_name.startswith("C2Tuple") or method_name.startswith("C3Tuple") or method_name.startswith("C4Tuple"):

             tuple_name = method_name.rsplit("Z", 1)[0][2:] + "Z"
             if method_name.startswith("C2Tuple"):
                 struct_meth = "Two" + tuple_name
                 expected_struct = "LDKC2" + tuple_name
             tuple_name = method_name.rsplit("Z", 1)[0][2:] + "Z"
             if method_name.startswith("C2Tuple"):
                 struct_meth = "Two" + tuple_name
                 expected_struct = "LDKC2" + tuple_name

-            else:
+            elif method_name.startswith("C3Tuple"):

                 struct_meth = "Three" + tuple_name
                 expected_struct = "LDKC3" + tuple_name
                 struct_meth = "Three" + tuple_name
                 expected_struct = "LDKC3" + tuple_name

+            else:
+                struct_meth = "Four" + tuple_name
+                expected_struct = "LDKC4" + tuple_name

             struct_meth_name = method_name[len(tuple_name) + 2:].strip("_")
         else:
             struct_meth = method_name.split("_")[0]
             struct_meth_name = method_name[len(tuple_name) + 2:].strip("_")
         else:
             struct_meth = method_name.split("_")[0]


@@ -565,6 +601,9 @@ with open(sys.argv[1]) as in_h, open(f"{sys.argv[2]}/bindings{consts.file_ext}",
             return_type_info = type_mapping_generator.map_type(method_return_type.strip() + " ret", True, ret_arr_len, False, force_holds_ref)
 
         if method_name.endswith("_clone") and expected_struct not in unitary_enums:
             return_type_info = type_mapping_generator.map_type(method_return_type.strip() + " ret", True, ret_arr_len, False, force_holds_ref)
 
         if method_name.endswith("_clone") and expected_struct not in unitary_enums:

+            # LDKWitness is mapped as an array, so no need to implement clone
+            if expected_struct == "LDKWitness":
+                return

             meth_line = "uint64_t " + expected_struct.replace("LDK", "") + "_clone_ptr(" + expected_struct + " *NONNULL_PTR arg)"
             write_c("static inline " + meth_line + " {\n")
             write_c("\t" + return_type_info.ret_conv[0].replace("\n", "\n\t"))
             meth_line = "uint64_t " + expected_struct.replace("LDK", "") + "_clone_ptr(" + expected_struct + " *NONNULL_PTR arg)"
             write_c("static inline " + meth_line + " {\n")
             write_c("\t" + return_type_info.ret_conv[0].replace("\n", "\n\t"))


@@ -631,11 +670,12 @@ with open(sys.argv[1]) as in_h, open(f"{sys.argv[2]}/bindings{consts.file_ext}",
             expected_struct in complex_enums or expected_struct in complex_enums or
             expected_struct in result_types or expected_struct in tuple_types) and not is_free
         impl_on_utils = not impl_on_struct and (not is_free and not method_name.endswith("_clone") and
             expected_struct in complex_enums or expected_struct in complex_enums or
             expected_struct in result_types or expected_struct in tuple_types) and not is_free
         impl_on_utils = not impl_on_struct and (not is_free and not method_name.endswith("_clone") and

-            not method_name.startswith("TxOut") and not method_name.startswith("BigEndianScalar") and
+            not method_name.startswith("TxOut") and not method_name.startswith("TxIn") and
+            not method_name.startswith("BigEndianScalar") and not method_name.startswith("WitnessProgram") and

             not method_name.startswith("_") and
             method_name != "check_platform" and method_name != "Result_read" and
             not expected_struct in unitary_enums and
             not method_name.startswith("_") and
             method_name != "check_platform" and method_name != "Result_read" and
             not expected_struct in unitary_enums and

-            ((not method_name.startswith("C2Tuple_") and not method_name.startswith("C3Tuple_"))
+            ((not method_name.startswith("C2Tuple_") and not method_name.startswith("C3Tuple_") and not method_name.startswith("C4Tuple_"))

               or method_name.endswith("_read")))
 
         # If we're adding a static method, and it returns a primitive or an array of primitives,
               or method_name.endswith("_read")))
 
         # If we're adding a static method, and it returns a primitive or an array of primitives,


@@ -765,13 +805,20 @@ with open(sys.argv[1]) as in_h, open(f"{sys.argv[2]}/bindings{consts.file_ext}",
             for var_line in field_var_lines:
                 if var_line.group(1) in trait_structs:
                     field_var_convs.append((var_line.group(1), var_line.group(2), trait_structs[var_line.group(1)]))
             for var_line in field_var_lines:
                 if var_line.group(1) in trait_structs:
                     field_var_convs.append((var_line.group(1), var_line.group(2), trait_structs[var_line.group(1)]))

-                    flattened_field_var_convs.append((var_line.group(1), var_line.group(2), ))
-                    flattened_field_var_convs.extend(trait_structs[var_line.group(1)])
+                    flattened_field_var_convs.append((var_line.group(1), var_line.group(2), var_line.group(2)))
+                    for field_var in trait_structs[var_line.group(1)]:
+                        if isinstance(field_var, ConvInfo):
+                            flattened_field_var_convs.append(field_var)
+                        else:
+                            path = var_line.group(2)
+                            if len(field_var) > 2:
+                                path = var_line.group(2) + "." + field_var[2]
+                            flattened_field_var_convs.append((field_var[0], field_var[1], path))

                 else:
                     mapped = type_mapping_generator.map_type(var_line.group(1) + " " + var_line.group(2), False, None, False, False)
                     field_var_convs.append(mapped)
                     flattened_field_var_convs.append(mapped)
                 else:
                     mapped = type_mapping_generator.map_type(var_line.group(1) + " " + var_line.group(2), False, None, False, False)
                     field_var_convs.append(mapped)
                     flattened_field_var_convs.append(mapped)

-            trait_structs[struct_name] = field_var_convs
+            trait_structs[struct_name] = flattened_field_var_convs

 
             field_fns = []
             for fn_docs, fn_line in trait_fn_lines:
 
             field_fns = []
             for fn_docs, fn_line in trait_fn_lines:


@@ -871,7 +918,7 @@ with open(sys.argv[1]) as in_h, open(f"{sys.argv[2]}/bindings{consts.file_ext}",
         map_fn_with_ref_option(dummy_line, reg_fn_regex.match(dummy_line), None, None, "", holds_ref)
 
     def map_tuple(struct_name, field_lines):
         map_fn_with_ref_option(dummy_line, reg_fn_regex.match(dummy_line), None, None, "", holds_ref)
 
     def map_tuple(struct_name, field_lines):

-        human_ty = struct_name.replace("LDKC2Tuple", "TwoTuple").replace("LDKC3Tuple", "ThreeTuple")
+        human_ty = struct_name.replace("LDKC2Tuple", "TwoTuple").replace("LDKC3Tuple", "ThreeTuple").replace("LDKC4Tuple", "FourTuple")

         with open(f"{sys.argv[3]}/structs/{human_ty}{consts.file_ext}", "w") as out_java_struct:
             out_java_struct.write(consts.map_tuple(struct_name))
             ty_list = []
         with open(f"{sys.argv[3]}/structs/{human_ty}{consts.file_ext}", "w") as out_java_struct:
             out_java_struct.write(consts.map_tuple(struct_name))
             ty_list = []


@@ -970,7 +1017,7 @@ with open(sys.argv[1]) as in_h, open(f"{sys.argv[2]}/bindings{consts.file_ext}",
                         vec_ty_match = line_indicates_vec_regex.match(struct_line)
                         if vec_ty_match is not None and struct_name.startswith("LDKCVec_"):
                             vec_ty = vec_ty_match.group(2)
                         vec_ty_match = line_indicates_vec_regex.match(struct_line)
                         if vec_ty_match is not None and struct_name.startswith("LDKCVec_"):
                             vec_ty = vec_ty_match.group(2)

-                        elif struct_name.startswith("LDKC2Tuple_") or struct_name.startswith("LDKC3Tuple_"):
+                        elif struct_name.startswith("LDKC2Tuple_") or struct_name.startswith("LDKC3Tuple_") or struct_name.startswith("LDKC4Tuple_"):

                             is_tuple = True
                         trait_fn_match = line_indicates_trait_regex.match(struct_line)
                         if trait_fn_match is not None:
                             is_tuple = True
                         trait_fn_match = line_indicates_trait_regex.match(struct_line)
                         if trait_fn_match is not None:


@@ -1069,16 +1116,11 @@ with open(sys.argv[1]) as in_h, open(f"{sys.argv[2]}/bindings{consts.file_ext}",
                         out_java_struct.write(consts.hu_struct_file_prefix)
                         out_java_struct.write(consts.txout_defn)
                         out_java_struct.write(consts.hu_struct_file_suffix)
                         out_java_struct.write(consts.hu_struct_file_prefix)
                         out_java_struct.write(consts.txout_defn)
                         out_java_struct.write(consts.hu_struct_file_suffix)

-                        fn_line = "struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)"
-                        write_c(fn_line + " {")
-                        write_c("\treturn CVec_u8Z_clone(&thing->script_pubkey);")
-                        write_c("}")
-                        map_fn(fn_line + "\n", re.compile("(.*) (TxOut_get_script_pubkey) \((.*)\)").match(fn_line), None, None, None)
-                        fn_line = "uint64_t TxOut_get_value (struct LDKTxOut* thing)"
-                        write_c(fn_line + " {")
-                        write_c("\treturn thing->value;")
-                        write_c("}")
-                        map_fn(fn_line + "\n", re.compile("(.*) (TxOut_get_value) \((.*)\)").match(fn_line), None, None, None)
+                elif struct_name == "LDKTxIn":
+                    with open(f"{sys.argv[3]}/structs/TxIn{consts.file_ext}", "w") as out_java_struct:
+                        out_java_struct.write(consts.hu_struct_file_prefix)
+                        out_java_struct.write(consts.txin_defn)
+                        out_java_struct.write(consts.hu_struct_file_suffix)

                 elif struct_name == "LDKBigEndianScalar":
                     with open(f"{sys.argv[3]}/structs/BigEndianScalar{consts.file_ext}", "w") as out_java_struct:
                         out_java_struct.write(consts.hu_struct_file_prefix)
                 elif struct_name == "LDKBigEndianScalar":
                     with open(f"{sys.argv[3]}/structs/BigEndianScalar{consts.file_ext}", "w") as out_java_struct:
                         out_java_struct.write(consts.hu_struct_file_prefix)


@@ -1099,6 +1141,11 @@ with open(sys.argv[1]) as in_h, open(f"{sys.argv[2]}/bindings{consts.file_ext}",
                         fn_line = "static void BigEndianScalar_free (struct LDKBigEndianScalar thing)"
                         write_c(fn_line + " {}\n")
                         map_fn(fn_line + "\n", re.compile("static (.*) (BigEndianScalar_free) \((.*)\)").match(fn_line), None, None, None)
                         fn_line = "static void BigEndianScalar_free (struct LDKBigEndianScalar thing)"
                         write_c(fn_line + " {}\n")
                         map_fn(fn_line + "\n", re.compile("static (.*) (BigEndianScalar_free) \((.*)\)").match(fn_line), None, None, None)

+                elif struct_name == "LDKWitnessProgram":
+                    with open(f"{sys.argv[3]}/structs/WitnessProgram{consts.file_ext}", "w") as out_java_struct:
+                        out_java_struct.write(consts.hu_struct_file_prefix)
+                        out_java_struct.write(consts.witness_program_defn)
+                        out_java_struct.write(consts.hu_struct_file_suffix)

                 else:
                     pass # Everything remaining is a byte[] of some form
                 cur_block_obj = None
                 else:
                     pass # Everything remaining is a byte[] of some form
                 cur_block_obj = None


@@ -1148,7 +1195,7 @@ with open(sys.argv[1]) as in_h, open(f"{sys.argv[2]}/bindings{consts.file_ext}",
         with open(f"{sys.argv[3]}/structs/{struct_name.replace('LDKCResult', 'Result')}{consts.file_ext}", "a") as out_java_struct:
             out_java_struct.write("}\n" + consts.hu_struct_file_suffix)
     for struct_name in tuple_types:
         with open(f"{sys.argv[3]}/structs/{struct_name.replace('LDKCResult', 'Result')}{consts.file_ext}", "a") as out_java_struct:
             out_java_struct.write("}\n" + consts.hu_struct_file_suffix)
     for struct_name in tuple_types:

-        struct_hu_name = struct_name.replace("LDKC2Tuple", "TwoTuple").replace("LDKC3Tuple", "ThreeTuple")
+        struct_hu_name = struct_name.replace("LDKC2Tuple", "TwoTuple").replace("LDKC3Tuple", "ThreeTuple").replace("LDKC4Tuple", "FourTuple")

         with open(f"{sys.argv[3]}/structs/{struct_hu_name}{consts.file_ext}", "a") as out_java_struct:
             out_java_struct.write("}\n" + consts.hu_struct_file_suffix)
 
         with open(f"{sys.argv[3]}/structs/{struct_hu_name}{consts.file_ext}", "a") as out_java_struct:
             out_java_struct.write("}\n" + consts.hu_struct_file_suffix)