./genbindings.sh ./ldk-c-bindings/ "-I$JAVA_HOME/include/ -I$JAVA_HOME/include/darwin -isysroot$(xcrun --show-sdk-path)" false false || echo
cat src/main/resources/liblightningjni_MacOSX-aarch64.nativelib > /dev/null
fi
- - name: Fetch Maven 3.8.3
+ - name: Fetch Maven 3.8.4
run: |
- wget -O apache-maven-3.8.3-bin.tar.gz https://apache.osuosl.org/maven/maven-3/3.8.3/binaries/apache-maven-3.8.3-bin.tar.gz
- if [ "$(shasum -a 256 apache-maven-3.8.3-bin.tar.gz | awk '{ print $1 }')" != "0f1597d11085b8fe93d84652a18c6deea71ece9fabba45a02cf6600c7758fd5b" ]; then
+ # We don't bother using the upstream mirrors as they remove prior
+ # releases aggressively, causing spurious CI failures when we don't
+ # care about the version used.
+ wget -O apache-maven-3.8.4-bin.tar.gz https://bitcoin.ninja/apache-maven-3.8.4-bin.tar.gz
+ if [ "$(shasum -a 256 apache-maven-3.8.4-bin.tar.gz | awk '{ print $1 }')" != "2cdc9c519427bb20fdc25bef5a9063b790e4abd930e7b14b4e9f4863d6f9f13c" ]; then
echo "Bad hash"
exit 1
fi
- tar xvvf apache-maven-3.8.3-bin.tar.gz
- export PATH=apache-maven-3.8.3/bin:$PATH
+ tar xvvf apache-maven-3.8.4-bin.tar.gz
+ export PATH=apache-maven-3.8.4/bin:$PATH
- name: Run Java Tests against built jar
run: |
- mvn -DskipTests=true package
+ mvn -q -B -DskipTests=true package
export LDK_GARBAGECOLLECTED_GIT_OVERRIDE="$(git describe --tag HEAD)"
JAR_VERSION=${LDK_GARBAGECOLLECTED_GIT_OVERRIDE:1:100}
mvn install:install-file -Dfile=target/ldk-java-${JAR_VERSION}.jar -DgroupId=org.lightningdevkit -DartifactId=ldk-java -Dversion=1.0-SNAPSHOT -Dpackaging=jar
cd javatester
- mvn package
+ mvn -q -B package
java -ea -jar target/ldk-java-tests-1.0-SNAPSHOT-jar-with-dependencies.jar
cd ..
- name: Check latest release libs are in git
export LDK_GARBAGECOLLECTED_GIT_OVERRIDE="$(git describe --tag HEAD)"
cp "ldk-java-bins/${LDK_GARBAGECOLLECTED_GIT_OVERRIDE}/"liblightningjni_MacOSX-{x86_64,aarch64}.nativelib src/main/resources/
mvn clean
- mvn -DskipTests=true package
+ mvn -q -B -DskipTests=true package
JAR_VERSION=${LDK_GARBAGECOLLECTED_GIT_OVERRIDE:1:100}
mvn install:install-file -Dfile=target/ldk-java-${JAR_VERSION}.jar -DgroupId=org.lightningdevkit -DartifactId=ldk-java -Dversion=1.0-SNAPSHOT -Dpackaging=jar
cd javatester
- mvn package
+ mvn -q -B package
java -ea -jar target/ldk-java-tests-1.0-SNAPSHOT-jar-with-dependencies.jar
cd ..
fi
class TypeInfo:
- def __init__(self, is_native_primitive, rust_obj, java_ty, java_fn_ty_arg, java_hu_ty, c_ty, is_const, passed_as_ptr, is_ptr, nonnull_ptr, var_name, arr_len, arr_access, subty=None):
+ def __init__(self, is_native_primitive, rust_obj, java_ty, java_fn_ty_arg, java_hu_ty, c_ty, is_const, passed_as_ptr, is_ptr, nonnull_ptr, var_name, arr_len, arr_access, subty=None, contains_trait=False):
self.is_native_primitive = is_native_primitive
self.rust_obj = rust_obj
self.java_ty = java_ty
self.subty = subty
self.pass_by_ref = is_ptr
self.requires_clone = None
+ self.contains_trait = contains_trait
def get_full_rust_ty(self):
ret = ""
self.docs = docs
class ComplexEnumVariantInfo:
- def __init__(self, var_name, fields, tuple_variant):
+ def __init__(self, var_name, var_docs, fields, tuple_variant):
self.var_name = var_name
+ self.var_docs = var_docs
self.fields = fields
self.tuple_variant = tuple_variant
(set_pfx, set_sfx) = self.consts.set_native_arr_contents(arr_name + "_arr", arr_len, ty_info)
ret_conv = ("int8_tArray " + arr_name + "_arr = " + self.consts.create_native_arr_call(arr_len, ty_info) + ";\n" + set_pfx, "")
arg_conv_cleanup = None
+ from_hu_conv = None
if not arr_len.isdigit():
arg_conv = ty_info.rust_obj + " " + arr_name + "_ref;\n"
arg_conv = arg_conv + arr_name + "_ref." + arr_len + " = " + self.consts.get_native_arr_len_call[0] + arr_name + self.consts.get_native_arr_len_call[1] + ";\n"
arg_conv = arg_conv + "CHECK(" + self.consts.get_native_arr_len_call[0] + arr_name + self.consts.get_native_arr_len_call[1] + " == " + arr_len + ");\n"
arg_conv = arg_conv + self.consts.get_native_arr_contents(arr_name, arr_name + "_ref." + ty_info.arr_access, arr_len, ty_info, True) + ";"
ret_conv = (ret_conv[0], "." + ty_info.arr_access + set_sfx + ";")
+ from_hu_conv = ("InternalUtils.check_arr_len(" + arr_name + ", " + arr_len + ")", "")
else:
arg_conv = "unsigned char " + arr_name + "_arr[" + arr_len + "];\n"
arg_conv = arg_conv + "CHECK(" + self.consts.get_native_arr_len_call[0] + arr_name + self.consts.get_native_arr_len_call[1] + " == " + arr_len + ");\n"
arg_conv = arg_conv + self.consts.get_native_arr_contents(arr_name, arr_name + "_arr", arr_len, ty_info, True) + ";\n"
arg_conv = arg_conv + "unsigned char (*" + arr_name + "_ref)[" + arr_len + "] = &" + arr_name + "_arr;"
ret_conv = (ret_conv[0] + "*", set_sfx + ";")
+ from_hu_conv = ("InternalUtils.check_arr_len(" + arr_name + ", " + arr_len + ")", "")
return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
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", to_hu_conv = None, to_hu_conv_name = None, from_hu_conv = None)
+ ret_conv = ret_conv, ret_conv_name = arr_name + "_arr", to_hu_conv = None, to_hu_conv_name = None,
+ from_hu_conv = from_hu_conv)
else:
assert not arr_len.isdigit() # fixed length arrays not implemented
assert ty_info.java_ty[len(ty_info.java_ty) - 2:] == "[]"
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"
if ty_info.is_ptr and holds_ref:
- opaque_arg_conv = opaque_arg_conv + ty_info.var_name + "_conv.is_owned = false;"
+ opaque_arg_conv += ty_info.var_name + "_conv.is_owned = false;\n"
else:
- 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.var_name + "_conv.is_owned = (" + ty_info.var_name + " & 1) || (" + ty_info.var_name + " == 0);\n"
+ opaque_arg_conv += "CHECK_INNER_FIELD_ACCESS_OR_NULL(" + ty_info.var_name + "_conv);"
if not is_free and (not ty_info.is_ptr or not holds_ref or ty_info.requires_clone == True) and ty_info.requires_clone != False:
if (ty_info.rust_obj.replace("LDK", "") + "_clone") in self.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 + "\n" + ty_info.var_name + "_conv = " + ty_info.rust_obj.replace("LDK", "") + "_clone(&" + ty_info.var_name + "_conv);"
- from_hu_conv = (from_hu_conv[0], "")
+ # arg_conv is used when converting a function argument from java normally (with holds_ref set),
+ # and when converting a java value being returned from a trait method (with holds_ref unset).
+ # In the second case, we need to clone before returning to C (as once we return the GC can free the object),
+ # whereas in the first we prefer to clone in C to avoid additional Java code as much as possible.
+ if holds_ref:
+ opaque_arg_conv = opaque_arg_conv + "\n" + ty_info.var_name + "_conv = " + ty_info.rust_obj.replace("LDK", "") + "_clone(&" + ty_info.var_name + "_conv);"
+ from_hu_conv = (from_hu_conv[0], "")
+ else:
+ from_hu_conv = (ty_info.var_name + " == null ? 0 : " + ty_info.var_name + ".clone_ptr()", "")
elif ty_info.passed_as_ptr:
opaque_arg_conv = opaque_arg_conv + "\n// Warning: we need a move here but no clone is available for " + ty_info.rust_obj
# TODO: Once we support features cloning (which just isn't in C yet), we can make this a compile error instead!
opaque_ret_conv_suf += indent + "CHECK((((uint64_t)" + ty_info.var_name + "_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.\n"
opaque_ret_conv_suf += indent + "CHECK((((uint64_t)&" + ty_info.var_name + "_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.\n"
+ opaque_ret_conv_suf += "CHECK_INNER_FIELD_ACCESS_OR_NULL(" + ty_info.var_name + "_var);\n"
if holds_ref:
opaque_ret_conv_suf += indent + ty_info.var_name + "_ref = (uint64_t)" + ty_info.var_name + "_var.inner & ~1;"
else:
base_conv = "void* " + ty_info.var_name + "_ptr = (void*)(((uint64_t)" + ty_info.var_name + ") & ~1);\n"
base_conv += "CHECK_ACCESS(" + ty_info.var_name + "_ptr);\n"
base_conv += ty_info.rust_obj + " " + ty_info.var_name + "_conv = *(" + ty_info.rust_obj + "*)(" + ty_info.var_name + "_ptr);"
+ from_hu_conv = None
if ty_info.rust_obj in self.trait_structs:
ret_conv = (ty_info.rust_obj + "* " + ty_info.var_name + "_ret = MALLOC(sizeof(" + ty_info.rust_obj + "), \"" + ty_info.rust_obj + "\");\n*" + ty_info.var_name + "_ret = ", ";")
if holds_ref:
if not is_free:
needs_full_clone = not is_free and (not ty_info.is_ptr and not holds_ref or ty_info.requires_clone == True) and ty_info.requires_clone != False
if needs_full_clone and (ty_info.rust_obj.replace("LDK", "") + "_clone") in self.clone_fns:
- base_conv = base_conv + "\n" + ty_info.var_name + "_conv = " + ty_info.rust_obj.replace("LDK", "") + "_clone(&" + ty_info.var_name + "_conv);"
+ # arg_conv is used when converting a function argument from java normally (with holds_ref set),
+ # and when converting a java value being returned from a trait method (with holds_ref unset).
+ # In the second case, we need to clone before returning to C (as once we return the GC can free the object),
+ # whereas in the first we prefer to clone in C to avoid additional Java code as much as possible.
+ if holds_ref:
+ base_conv += "\n" + ty_info.var_name + "_conv = " + ty_info.rust_obj.replace("LDK", "") + "_clone(&" + ty_info.var_name + "_conv);"
+ else:
+ from_hu_conv = (ty_info.var_name + " == null ? 0 : " + ty_info.var_name + ".clone_ptr()", "")
+ base_conv += "\n" + "FREE((void*)" + ty_info.var_name + ");"
else:
base_conv = base_conv + self.consts.trait_struct_inc_refcnt(ty_info)
if needs_full_clone:
base_conv = base_conv + "// Warning: we may need a move here but no clone is available for " + ty_info.rust_obj + "\n"
else:
base_conv = base_conv + "\n" + "FREE((void*)" + ty_info.var_name + ");"
+ if from_hu_conv is None:
+ from_hu_conv = (ty_info.var_name + " == null ? 0 : " + ty_info.var_name + ".ptr", "")
+ from_hu_conv = (from_hu_conv[0], "this.ptrs_to.add(" + 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_cleanup = None,
ret_conv = ret_conv, ret_conv_name = "(uint64_t)" + ty_info.var_name + "_ret",
to_hu_conv = ty_info.java_hu_ty + " ret_hu_conv = new " + ty_info.java_hu_ty + "(null, " + ty_info.var_name + ");\nret_hu_conv.ptrs_to.add(this);",
- to_hu_conv_name = "ret_hu_conv",
- from_hu_conv = (ty_info.var_name + " == null ? 0 : " + ty_info.var_name + ".ptr", "this.ptrs_to.add(" + ty_info.var_name + ")"))
+ to_hu_conv_name = "ret_hu_conv", from_hu_conv = from_hu_conv)
needs_full_clone = not is_free and (not ty_info.is_ptr or ty_info.requires_clone == True) and ty_info.requires_clone != False
if needs_full_clone:
if "res" in ty_info.var_name: # XXX: This is a stupid hack
needs_full_clone = False
if needs_full_clone and (ty_info.rust_obj.replace("LDK", "") + "_clone") in self.clone_fns:
- base_conv = base_conv + "\n" + ty_info.var_name + "_conv = " + ty_info.rust_obj.replace("LDK", "") + "_clone((" + ty_info.rust_obj + "*)(((uint64_t)" + ty_info.var_name + ") & ~1));"
+ # arg_conv is used when converting a function argument from java normally (with holds_ref set),
+ # and when converting a java value being returned from a trait method (with holds_ref unset).
+ # In the second case, we need to clone before returning to C (as once we return the GC can free the object),
+ # whereas in the first we prefer to clone in C to avoid additional Java code as much as possible.
+ if holds_ref:
+ base_conv += "\n" + ty_info.var_name + "_conv = " + ty_info.rust_obj.replace("LDK", "") + "_clone((" + ty_info.rust_obj + "*)(((uint64_t)" + ty_info.var_name + ") & ~1));"
+ else:
+ from_hu_conv = (ty_info.var_name + " == null ? 0 : " + ty_info.var_name + ".clone_ptr()", "")
+ base_conv += "\n" + "FREE((void*)" + ty_info.var_name + ");"
elif needs_full_clone:
base_conv = base_conv + "\n// Warning: we may need a move here but no clone is available for " + ty_info.rust_obj
if not needs_full_clone and ty_info.rust_obj != "LDKu8slice" and (not holds_ref or is_free):
# underlying unlike Vecs, and it gives Java more freedom.
base_conv = base_conv + "\nFREE((void*)" + ty_info.var_name + ");"
if ty_info.rust_obj in self.complex_enums:
+ to_hu_conv_sfx = ""
if needs_full_clone and (ty_info.rust_obj.replace("LDK", "") + "_clone") not in self.clone_fns:
# We really need a full clone here, but for now we just implement
# a manual clone explicitly for Option<Trait>s
- if ty_info.rust_obj.startswith("LDKCOption"):
+ if ty_info.contains_trait:
+ assert ty_info.rust_obj.startswith("LDKCOption") # We don't support contained traits for anything else yet
optional_ty = ty_info.rust_obj[11:-1]
- if "LDK" + optional_ty in self.trait_structs:
- base_conv += "\nif (" + ty_info.var_name + "_conv.tag == " + ty_info.rust_obj + "_Some) {"
- base_conv += "\n\t// Manually implement clone for Java trait instances"
- optional_ty_info = self.java_c_types("LDK" + optional_ty + " " + ty_info.var_name, None)
- base_conv += self.consts.trait_struct_inc_refcnt(optional_ty_info).\
- replace("\n", "\n\t").replace(ty_info.var_name + "_conv", ty_info.var_name + "_conv.some")
- base_conv += "\n}"
+ assert "LDK" + optional_ty in self.trait_structs # We don't support contained traits for anything else yet
+ to_hu_conv_sfx = "this.ptrs_to.add(" + ty_info.var_name + ")"
+ base_conv += "\nif (" + ty_info.var_name + "_conv.tag == " + ty_info.rust_obj + "_Some) {"
+ base_conv += "\n\t// Manually implement clone for Java trait instances"
+ optional_ty_info = self.java_c_types("LDK" + optional_ty + " " + ty_info.var_name, None)
+ base_conv += self.consts.trait_struct_inc_refcnt(optional_ty_info).\
+ replace("\n", "\n\t").replace(ty_info.var_name + "_conv", ty_info.var_name + "_conv.some")
+ base_conv += "\n}"
ret_conv = ("uint64_t " + ty_info.var_name + "_ref = ((uint64_t)&", ") | 1;")
if not holds_ref:
ret_conv = (ty_info.rust_obj + " *" + ty_info.var_name + "_copy = MALLOC(sizeof(" + ty_info.rust_obj + "), \"" + ty_info.rust_obj + "\");\n", "")
ret_conv = (ret_conv[0] + "*" + ty_info.var_name + "_copy = ", "")
ret_conv = (ret_conv[0], ";\nuint64_t " + ty_info.var_name + "_ref = (uint64_t)" + ty_info.var_name + "_copy;")
+ if from_hu_conv is None:
+ from_hu_conv = (ty_info.var_name + ".ptr", "")
+ from_hu_conv = (from_hu_conv[0], to_hu_conv_sfx)
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_cleanup = None,
ret_conv = ret_conv, ret_conv_name = ty_info.var_name + "_ref",
to_hu_conv = ty_info.java_hu_ty + " " + ty_info.var_name + "_hu_conv = " + ty_info.java_hu_ty + ".constr_from_ptr(" + ty_info.var_name + ");\n" + ty_info.var_name + "_hu_conv.ptrs_to.add(this);",
- to_hu_conv_name = ty_info.var_name + "_hu_conv", from_hu_conv = (ty_info.var_name + ".ptr", ""))
+ to_hu_conv_name = ty_info.var_name + "_hu_conv", from_hu_conv = from_hu_conv)
if ty_info.rust_obj in self.result_types:
if holds_ref:
# If we're trying to return a ref, we have to clone.
ret_conv = (ret_conv[0], ret_conv[1] + "\n*" + ty_info.var_name + "_conv = " + ty_info.rust_obj.replace("LDK", "") + "_clone(" + ty_info.var_name + "_conv);")
else:
ret_conv = (ty_info.rust_obj + "* " + ty_info.var_name + "_conv = MALLOC(sizeof(" + ty_info.rust_obj + "), \"" + ty_info.rust_obj + "\");\n*" + ty_info.var_name + "_conv = ", ";")
+ if from_hu_conv is None:
+ from_hu_conv = (ty_info.var_name + " != null ? " + ty_info.var_name + ".ptr : 0", "")
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_cleanup = None,
ret_conv = ret_conv, ret_conv_name = "(uint64_t)" + ty_info.var_name + "_conv",
to_hu_conv = ty_info.java_hu_ty + " " + ty_info.var_name + "_hu_conv = " + ty_info.java_hu_ty + ".constr_from_ptr(" + ty_info.var_name + ");",
- to_hu_conv_name = ty_info.var_name + "_hu_conv", from_hu_conv = (ty_info.var_name + " != null ? " + ty_info.var_name + ".ptr : 0", ""))
+ to_hu_conv_name = ty_info.var_name + "_hu_conv", from_hu_conv = from_hu_conv)
if ty_info.rust_obj in self.tuple_types:
ret_conv_name = "((uint64_t)" + ty_info.var_name + "_conv)"
if holds_ref:
to_hu_conv_sfx = "\n" + ty_info.var_name + "_hu_conv.ptrs_to.add(this);"
else:
to_hu_conv_sfx = ""
+ if from_hu_conv is None:
+ from_hu_conv = (ty_info.var_name + " != null ? " + ty_info.var_name + ".ptr : 0", "")
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_cleanup = None,
ret_conv = ret_conv, ret_conv_name = ret_conv_name,
to_hu_conv = ty_info.java_hu_ty + " " + ty_info.var_name + "_hu_conv = new " + ty_info.java_hu_ty + "(null, " + ty_info.var_name + ");" + to_hu_conv_sfx,
- to_hu_conv_name = ty_info.var_name + "_hu_conv", from_hu_conv = (ty_info.var_name + " != null ? " + ty_info.var_name + ".ptr : 0", ""))
+ to_hu_conv_name = ty_info.var_name + "_hu_conv", from_hu_conv = from_hu_conv)
# The manually-defined types - TxOut and u5
if ty_info.rust_obj == "LDKu5":
+ assert from_hu_conv is None
return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
arg_conv = "", arg_conv_name = "(LDKu5){ ._0 = " + ty_info.var_name + " }", arg_conv_cleanup = None,
ret_conv = ("uint8_t " + ty_info.var_name + "_val = ", "._0;"), ret_conv_name = ty_info.var_name + "_val",
return (params, ret_null)
unitary_enums = set()
-complex_enums = set()
+# Map from enum name to "contains trait object"
+complex_enums = {}
opaque_structs = set()
trait_structs = {}
result_types = set()
var_name=res.var_name, arr_len="datalen", arr_access="data", subty=res, is_native_primitive=False)
is_primitive = False
+ contains_trait = False
arr_len = None
mapped_type = []
java_type_plural = None
fn_ty_arg = "J"
fn_arg = ma.group(2).strip()
rust_obj = ma.group(1).strip()
+ if rust_obj in trait_structs:
+ contains_trait = True
+ elif rust_obj in complex_enums:
+ contains_trait = complex_enums[rust_obj]
take_by_ptr = True
if fn_arg.startswith(" *") or fn_arg.startswith("*"):
if var_is_arr.group(1) == "":
return TypeInfo(rust_obj=rust_obj, java_ty=java_ty, java_hu_ty=java_ty, java_fn_ty_arg="[" + fn_ty_arg, c_ty=c_ty, is_const=is_const,
passed_as_ptr=False, is_ptr=False, nonnull_ptr=nonnull_ptr, var_name="arg",
- arr_len=var_is_arr.group(2), arr_access=arr_access, is_native_primitive=False)
+ arr_len=var_is_arr.group(2), arr_access=arr_access, is_native_primitive=False, contains_trait=contains_trait)
return TypeInfo(rust_obj=rust_obj, java_ty=java_ty, java_hu_ty=java_ty, java_fn_ty_arg="[" + fn_ty_arg, c_ty=c_ty, is_const=is_const,
passed_as_ptr=False, is_ptr=False, nonnull_ptr=nonnull_ptr, var_name=var_is_arr.group(1),
- arr_len=var_is_arr.group(2), arr_access=arr_access, is_native_primitive=False)
+ arr_len=var_is_arr.group(2), arr_access=arr_access, is_native_primitive=False, contains_trait=contains_trait)
if java_hu_ty is None:
java_hu_ty = java_ty
return TypeInfo(rust_obj=rust_obj, java_ty=java_ty, java_hu_ty=java_hu_ty, java_fn_ty_arg=fn_ty_arg, c_ty=c_ty, passed_as_ptr=is_ptr or take_by_ptr,
- is_const=is_const, is_ptr=is_ptr, nonnull_ptr=nonnull_ptr, var_name=fn_arg, arr_len=arr_len, arr_access=arr_access, is_native_primitive=is_primitive)
+ is_const=is_const, is_ptr=is_ptr, nonnull_ptr=nonnull_ptr, var_name=fn_arg, arr_len=arr_len, arr_access=arr_access, is_native_primitive=is_primitive,
+ contains_trait=contains_trait)
fn_ptr_regex = re.compile("^extern const ([A-Za-z_0-9\* ]*) \(\*(.*)\)\((.*)\);$")
fn_ret_arr_regex = re.compile("(.*) \(\*(.*)\((.*)\)\)\[([0-9]*)\];$")
method_comma_separated_arguments = re_match.group(3)
method_arguments = method_comma_separated_arguments.split(',')
+ if method_name.startswith("__"):
+ return
+
is_free = method_name.endswith("_free")
if method_name.startswith("COption") or method_name.startswith("CResult"):
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"):
+ elif method_name.startswith("C2Tuple") or method_name.startswith("C3Tuple"):
tuple_name = method_name.rsplit("Z", 1)[0][2:] + "Z"
- struct_meth = "Two" + tuple_name
- expected_struct = "LDKC2" + tuple_name
+ if method_name.startswith("C2Tuple"):
+ struct_meth = "Two" + tuple_name
+ expected_struct = "LDKC2" + tuple_name
+ else:
+ struct_meth = "Three" + tuple_name
+ expected_struct = "LDKC3" + tuple_name
struct_meth_name = method_name[len(tuple_name) + 2:].strip("_")
else:
struct_meth = method_name.split("_")[0]
else:
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:
+ 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"))
+ write_c(method_name + "(arg)")
+ write_c(return_type_info.ret_conv[1])
+ write_c("\n\treturn " + return_type_info.ret_conv_name + ";\n}\n")
+ map_fn(meth_line + ";\n", re.compile("(uint64_t) ([A-Za-z_0-9]*)\((.*)\)").match(meth_line), None, None, None)
+
argument_types = []
default_constructor_args = {}
takes_self = False
elif idx == len(field_lines) - 1:
assert(struct_line == "")
assert struct_name.startswith("LDK")
- (c_out, native_file_out, native_out) = consts.native_c_unitary_enum_map(struct_name[3:], [x.strip().strip(",") for x, _ in field_lines[1:-3]], enum_doc_comment)
+ (c_out, native_file_out, native_out) = consts.native_c_unitary_enum_map(struct_name[3:], [(x.strip().strip(","), y) for x, y in field_lines[1:-3]], enum_doc_comment)
write_c(c_out)
out_java_enum.write(native_file_out)
out_java.write(native_out)
def map_complex_enum(struct_name, union_enum_items, inline_enum_variants, enum_doc_comment):
java_hu_type = struct_name.replace("LDK", "").replace("COption", "Option")
- complex_enums.add(struct_name)
enum_variants = []
tag_field_lines = union_enum_items["field_lines"]
- for idx, (struct_line, _) in enumerate(tag_field_lines):
+ contains_trait = False
+ for idx, (struct_line, variant_docs) in enumerate(tag_field_lines):
if idx == 0:
assert(struct_line == "typedef enum %s_Tag {" % struct_name)
elif idx == len(tag_field_lines) - 3:
for idx, (field, field_docs) in enumerate(enum_var_lines):
if idx != 0 and idx < len(enum_var_lines) - 2 and field.strip() != "":
field_ty = type_mapping_generator.java_c_types(field.strip(' ;'), None)
+ contains_trait |= field_ty.contains_trait
if field_docs is not None and doc_to_field_nullable(field_docs):
field_conv = type_mapping_generator.map_type_with_info(field_ty, False, None, False, True, True)
else:
field_conv = type_mapping_generator.map_type_with_info(field_ty, False, None, False, True, False)
fields.append((field_conv, field_docs))
- enum_variants.append(ComplexEnumVariantInfo(variant_name, fields, False))
+ enum_variants.append(ComplexEnumVariantInfo(variant_name, variant_docs, fields, False))
elif camel_to_snake(variant_name) in inline_enum_variants:
# TODO: If we ever have a rust enum Variant(Option<Struct>) we need to pipe
# docs through to there, and then potentially mark the field nullable.
- fields.append((type_mapping_generator.map_type(inline_enum_variants[camel_to_snake(variant_name)] + " " + camel_to_snake(variant_name), False, None, False, True), None))
- enum_variants.append(ComplexEnumVariantInfo(variant_name, fields, True))
+ mapped = type_mapping_generator.map_type(inline_enum_variants[camel_to_snake(variant_name)] + " " + camel_to_snake(variant_name), False, None, False, True)
+ contains_trait |= mapped.ty_info.contains_trait
+ fields.append((mapped, None))
+ enum_variants.append(ComplexEnumVariantInfo(variant_name, variant_docs, fields, True))
else:
- enum_variants.append(ComplexEnumVariantInfo(variant_name, fields, True))
+ enum_variants.append(ComplexEnumVariantInfo(variant_name, variant_docs, fields, True))
+ complex_enums[struct_name] = contains_trait
with open(f"{sys.argv[3]}/structs/{java_hu_type}{consts.file_ext}", "w") as out_java_enum:
(out_java_addendum, out_java_enum_addendum, out_c_addendum) = consts.map_complex_enum(struct_name, enum_variants, camel_to_snake, enum_doc_comment)
out_java_struct.write("\t\tif (ptr != 0) { bindings." + struct_name.replace("LDK","") + "_free(ptr); } super.finalize();\n")
out_java_struct.write("\t}\n\n")
out_java_struct.write("\tstatic " + human_ty + " constr_from_ptr(long ptr) {\n")
- out_java_struct.write("\t\tif (bindings." + struct_name + "_result_ok(ptr)) {\n")
+ out_java_struct.write("\t\tif (bindings." + struct_name.replace("LDK", "") + "_is_ok(ptr)) {\n")
out_java_struct.write("\t\t\treturn new " + human_ty + "_OK(null, ptr);\n")
out_java_struct.write("\t\t} else {\n")
out_java_struct.write("\t\t\treturn new " + human_ty + "_Err(null, ptr);\n")
if not err_map.is_native_primitive and (err_map.rust_obj.replace("LDK", "") + "_clone" not in clone_fns):
can_clone = False
- out_java.write("\tpublic static native boolean " + struct_name + "_result_ok(long arg);\n")
- write_c(consts.c_fn_ty_pfx + "jboolean " + consts.c_fn_name_define_pfx(struct_name + "_result_ok", True) + consts.ptr_c_ty + " arg) {\n")
- write_c("\treturn ((" + struct_name + "*)arg)->result_ok;\n")
- write_c("}\n")
-
out_java.write("\tpublic static native " + res_map.java_ty + " " + struct_name + "_get_ok(long arg);\n")
write_c(consts.c_fn_ty_pfx + res_map.c_ty + " " + consts.c_fn_name_define_pfx(struct_name + "_get_ok", True) + consts.ptr_c_ty + " arg) {\n")
write_c("\t" + struct_name + " *val = (" + struct_name + "*)(arg & ~1);\n")
last_struct_block_comment = block_comment.strip("\n")
block_comment = None
else:
- block_comment = block_comment + "\n" + struct_line.strip(" /*")
+ block_comment = block_comment + "\n" + struct_line.strip(" /*").replace("…", "...")
else:
struct_name_match = struct_name_regex.match(struct_line)
if struct_name_match is not None:
map_tuple(struct_name, field_lines)
elif vec_ty is not None:
ty_info = type_mapping_generator.map_type(vec_ty + " arr_elem", False, None, False, False)
- if len(ty_info.java_fn_ty_arg) == 1: # ie we're a primitive of some form
- out_java.write("\tpublic static native long " + struct_name + "_new(" + ty_info.java_ty + "[] elems);\n")
- write_c(consts.c_fn_ty_pfx + consts.ptr_c_ty + " " + consts.c_fn_name_define_pfx(struct_name + "_new", True) + ty_info.c_ty + "Array elems) {\n")
- write_c("\t" + struct_name + " *ret = MALLOC(sizeof(" + struct_name + "), \"" + struct_name + "\");\n")
- write_c("\tret->datalen = " + consts.get_native_arr_len_call[0] + "elems" + consts.get_native_arr_len_call[1] + ";\n")
- write_c("\tif (ret->datalen == 0) {\n")
- write_c("\t\tret->data = NULL;\n")
- write_c("\t} else {\n")
- write_c("\t\tret->data = MALLOC(sizeof(" + vec_ty + ") * ret->datalen, \"" + struct_name + " Data\");\n")
- native_arr_ptr_call = consts.get_native_arr_ptr_call(ty_info.ty_info)
- write_c("\t\t" + ty_info.c_ty + " *java_elems = " + native_arr_ptr_call[0] + "elems" + native_arr_ptr_call[1] + ";\n")
- write_c("\t\tfor (size_t i = 0; i < ret->datalen; i++) {\n")
- if ty_info.arg_conv is not None:
- write_c("\t\t\t" + ty_info.c_ty + " arr_elem = java_elems[i];\n")
- write_c("\t\t\t" + ty_info.arg_conv.replace("\n", "\n\t\t\t") + "\n")
- write_c("\t\t\tret->data[i] = " + ty_info.arg_conv_name + ";\n")
- assert ty_info.arg_conv_cleanup is None
- else:
- write_c("\t\t\tret->data[i] = java_elems[i];\n")
- write_c("\t\t}\n")
- cleanup = consts.release_native_arr_ptr_call(ty_info.ty_info, "elems", "java_elems")
- if cleanup is not None:
- write_c("\t\t" + cleanup + ";\n")
- write_c("\t}\n")
- write_c("\treturn (uint64_t)ret;\n")
- write_c("}\n")
-
if ty_info.is_native_primitive:
clone_fns.add(struct_name.replace("LDK", "") + "_clone")
write_c("static inline " + struct_name + " " + struct_name.replace("LDK", "") + "_clone(const " + struct_name + " *orig) {\n")
else
./genbindings.py "./lightning.h" src/main/java/org/ldk/impl src/main/java/org/ldk src/main/jni/ $DEBUG_ARG java $4
fi
-echo "#define LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ LDKCVec_TransactionOutputsZ" > src/main/jni/bindings.c
+rm -f src/main/jni/bindings.c
+if [ "$3" = "true" ]; then
+ echo "#define LDK_DEBUG_BUILD" > src/main/jni/bindings.c
+elif [ "$3" = "leaks" ]; then
+ # For leak checking we use release libldk which doesn't expose
+ # __unmangle_inner_ptr, but the C code expects to be able to call it.
+ echo "#define __unmangle_inner_ptr(a) (a)" > src/main/jni/bindings.c
+fi
+echo "#define LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ LDKCVec_TransactionOutputsZ" >> src/main/jni/bindings.c
echo "#define CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free CVec_TransactionOutputsZ_free" >> src/main/jni/bindings.c
cat src/main/jni/bindings.c.body >> src/main/jni/bindings.c
javac -h src/main/jni src/main/java/org/ldk/enums/*.java src/main/java/org/ldk/impl/*.java
self.util_fn_pfx = """package org.ldk.structs;
import org.ldk.impl.bindings;
+import org.ldk.enums.*;
+import org.ldk.util.*;
import java.util.Arrays;
import javax.annotation.Nullable;
-import org.ldk.enums.*;
public class UtilMethods {
"""
self.c_file_pfx = self.c_file_pfx + """#define MALLOC(a, _) malloc(a)
#define FREE(p) if ((uint64_t)(p) > 4096) { free(p); }
#define CHECK_ACCESS(p)
+#define CHECK_INNER_FIELD_ACCESS_OR_NULL(v)
"""
if not DEBUG:
self.c_file_pfx += """#define DO_ASSERT(a) (void)(a)
__real_free(ptr);
}
-static void CHECK_ACCESS(void* ptr) {
+static void CHECK_ACCESS(const void* ptr) {
DO_ASSERT(!pthread_mutex_lock(&allocation_mtx));
allocation* it = allocation_ll;
while (it->ptr != ptr) {
}
DO_ASSERT(!pthread_mutex_unlock(&allocation_mtx));
}
+#define CHECK_INNER_FIELD_ACCESS_OR_NULL(v) \\
+ if (v.is_owned && v.inner != NULL) { \\
+ const void *p = __unmangle_inner_ptr(v.inner); \\
+ if (p != NULL) { \\
+ CHECK_ACCESS(p); \\
+ } \\
+ }
void* __real_realloc(void* ptr, size_t newlen);
void* __wrap_realloc(void* ptr, size_t len) {
out_java_enum += "/**\n * " + enum_doc_comment.replace("\n", "\n * ") + "\n */\n"
out_java_enum += "public enum " + struct_name + " {\n"
ord_v = 0
- for var in variants:
- out_java_enum = out_java_enum + "\t" + var + ",\n"
+ for var, var_docs in variants:
+ if var_docs is not None:
+ out_java_enum += "\t/**\n\t * " + var_docs.replace("\n", "\n\t * ") + "\n\t */\n"
+ out_java_enum += "\t" + var + ",\n"
out_c = out_c + "\t\tcase %d: return %s;\n" % (ord_v, var)
ord_v = ord_v + 1
out_java_enum = out_java_enum + "\t; static native void init();\n"
out_c = out_c + "}\n"
out_c = out_c + "static jclass " + struct_name + "_class = NULL;\n"
- for var in variants:
+ for var, _ in variants:
out_c = out_c + "static jfieldID " + struct_name + "_" + var + " = NULL;\n"
out_c = out_c + self.c_fn_ty_pfx + "void JNICALL Java_org_ldk_enums_" + struct_name.replace("_", "_1") + "_init (" + self.c_fn_args_pfx + ") {\n"
out_c = out_c + "\t" + struct_name + "_class = (*env)->NewGlobalRef(env, clz);\n"
out_c = out_c + "\tCHECK(" + struct_name + "_class != NULL);\n"
- for var in variants:
+ for var, _ in variants:
out_c = out_c + "\t" + struct_name + "_" + var + " = (*env)->GetStaticFieldID(env, " + struct_name + "_class, \"" + var + "\", \"Lorg/ldk/enums/" + struct_name + ";\");\n"
out_c = out_c + "\tCHECK(" + struct_name + "_" + var + " != NULL);\n"
out_c = out_c + "}\n"
out_c = out_c + "static inline jclass LDK" + struct_name + "_to_java(JNIEnv *env, LDK" + struct_name + " val) {\n"
out_c = out_c + "\tswitch (val) {\n"
ord_v = 0
- for var in variants:
+ for var, _ in variants:
out_c = out_c + "\t\tcase " + var + ":\n"
out_c = out_c + "\t\t\treturn (*env)->GetStaticObjectField(env, " + struct_name + "_class, " + struct_name + "_" + var + ");\n"
ord_v = ord_v + 1
out_java += ("\t\tprivate " + struct_name + "() {}\n")
for var in variant_list:
out_java += ("\t\tpublic final static class " + var.var_name + " extends " + struct_name + " {\n")
- java_hu_subclasses = java_hu_subclasses + "\tpublic final static class " + var.var_name + " extends " + java_hu_type + " {\n"
+ if var.var_docs is not None:
+ java_hu_subclasses += "\t/**\n\t * " + var.var_docs.replace("\n", "\n\t * ") + "\n\t */\n"
+ java_hu_subclasses += "\tpublic final static class " + var.var_name + " extends " + java_hu_type + " {\n"
out_java_enum += ("\t\tif (raw_val.getClass() == bindings." + struct_name + "." + var.var_name + ".class) {\n")
out_java_enum += ("\t\t\treturn new " + var.var_name + "(ptr, (bindings." + struct_name + "." + var.var_name + ")raw_val);\n")
init_meth_jty_str = ""
out_java_struct += "\tpublic static " + return_type_info.java_hu_ty + " with_default("
else:
out_java_struct += "\tpublic static " + return_type_info.java_hu_ty + " " + meth_n + "("
+ elif meth_n == "clone_ptr":
+ out_java_struct += ("\t" + return_type_info.java_hu_ty + " " + meth_n + "(")
else:
out_java_struct += ("\tpublic " + return_type_info.java_hu_ty + " " + meth_n + "(")
for idx, arg in enumerate(argument_types):
* Note that if the provided Watch is a ChainWatch and has an associated filter, the previously registered
* outputs will be loaded when chain_sync_completed is called.
*/
- public ChannelManagerConstructor(byte[] channel_manager_serialized, byte[][] channel_monitors_serialized,
- KeysInterface keys_interface, FeeEstimator fee_estimator, ChainMonitor chain_monitor, @Nullable Filter filter,
- @Nullable NetworkGraph net_graph,
+ public ChannelManagerConstructor(byte[] channel_manager_serialized, byte[][] channel_monitors_serialized, UserConfig config,
+ KeysInterface keys_interface, FeeEstimator fee_estimator, ChainMonitor chain_monitor,
+ @Nullable Filter filter, @Nullable NetworkGraph net_graph,
BroadcasterInterface tx_broadcaster, Logger logger) throws InvalidSerializedDataException {
final IgnoringMessageHandler no_custom_messages = IgnoringMessageHandler.of();
final ChannelMonitor[] monitors = new ChannelMonitor[channel_monitors_serialized.length];
}
Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ res =
UtilMethods.C2Tuple_BlockHashChannelManagerZ_read(channel_manager_serialized, keys_interface, fee_estimator, chain_monitor.as_Watch(), tx_broadcaster,
- logger, UserConfig.with_default(), monitors);
+ logger, config, monitors);
if (res instanceof Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ.Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_Err) {
throw new InvalidSerializedDataException();
}
buf.get(read_bytes, 0, read);
long read_result_pointer = bindings.PeerManager_read_event(
peer_manager_raw_pointer, peer.descriptor_raw_pointer, read_bytes);
- if (bindings.LDKCResult_boolPeerHandleErrorZ_result_ok(read_result_pointer)) {
+ if (bindings.CResult_boolPeerHandleErrorZ_is_ok(read_result_pointer)) {
if (bindings.LDKCResult_boolPeerHandleErrorZ_get_ok(read_result_pointer)) {
key.interestOps(key.interestOps() & (~SelectionKey.OP_READ));
}
* An error when accessing the chain via [`Access`].
*/
public enum AccessError {
+ /**
+ * The requested chain is unknown.
+ */
LDKAccessError_UnknownChain,
+ /**
+ * The requested transaction doesn't exist or hasn't confirmed.
+ */
LDKAccessError_UnknownTx,
; static native void init();
static { init(); }
* An error enum representing a failure to persist a channel monitor update.
*/
public enum ChannelMonitorUpdateErr {
+ /**
+ * Used to indicate a temporary failure (eg connection to a watchtower or remote backup of
+ * our state failed, but is expected to succeed at some point in the future).
+ *
+ * Such a failure will \"freeze\" a channel, preventing us from revoking old states or
+ * submitting new commitment transactions to the counterparty. Once the update(s) that failed
+ * have been successfully applied, a [`MonitorEvent::UpdateCompleted`] event should be returned
+ * via [`Watch::release_pending_monitor_events`] which will then restore the channel to an
+ * operational state.
+ *
+ * Note that a given ChannelManager will *never* re-generate a given ChannelMonitorUpdate. If
+ * you return a TemporaryFailure you must ensure that it is written to disk safely before
+ * writing out the latest ChannelManager state.
+ *
+ * Even when a channel has been \"frozen\" updates to the ChannelMonitor can continue to occur
+ * (eg if an inbound HTLC which we forwarded was claimed upstream resulting in us attempting
+ * to claim it on this channel) and those updates must be applied wherever they can be. At
+ * least one such updated ChannelMonitor must be persisted otherwise PermanentFailure should
+ * be returned to get things on-chain ASAP using only the in-memory copy. Obviously updates to
+ * the channel which would invalidate previous ChannelMonitors are not made when a channel has
+ * been \"frozen\".
+ *
+ * Note that even if updates made after TemporaryFailure succeed you must still provide a
+ * [`MonitorEvent::UpdateCompleted`] to ensure you have the latest monitor and re-enable
+ * normal channel operation. Note that this is normally generated through a call to
+ * [`ChainMonitor::channel_monitor_updated`].
+ *
+ * Note that the update being processed here will not be replayed for you when you return a
+ * [`MonitorEvent::UpdateCompleted`] event via [`Watch::release_pending_monitor_events`], so
+ * you must store the update itself on your own local disk prior to returning a
+ * TemporaryFailure. You may, of course, employ a journaling approach, storing only the
+ * ChannelMonitorUpdate on disk without updating the monitor itself, replaying the journal at
+ * reload-time.
+ *
+ * For deployments where a copy of ChannelMonitors and other local state are backed up in a
+ * remote location (with local copies persisted immediately), it is anticipated that all
+ * updates will return TemporaryFailure until the remote copies could be updated.
+ *
+ * [`ChainMonitor::channel_monitor_updated`]: chainmonitor::ChainMonitor::channel_monitor_updated
+ */
LDKChannelMonitorUpdateErr_TemporaryFailure,
+ /**
+ * Used to indicate no further channel monitor updates will be allowed (eg we've moved on to a
+ * different watchtower and cannot update with all watchtowers that were previously informed
+ * of this channel).
+ *
+ * At reception of this error, ChannelManager will force-close the channel and return at
+ * least a final ChannelMonitorUpdate::ChannelForceClosed which must be delivered to at
+ * least one ChannelMonitor copy. Revocation secret MUST NOT be released and offchain channel
+ * update must be rejected.
+ *
+ * This failure may also signal a failure to update the local persisted copy of one of
+ * the channel monitor instance.
+ *
+ * Note that even when you fail a holder commitment transaction update, you must store the
+ * update to ensure you can claim from it in case of a duplicate copy of this ChannelMonitor
+ * broadcasts it (e.g distributed channel-monitor deployment)
+ *
+ * In case of distributed watchtowers deployment, the new version must be written to disk, as
+ * state may have been stored but rejected due to a block forcing a commitment broadcast. This
+ * storage is used to claim outputs of rejected state confirmed onchain by another watchtower,
+ * lagging behind on block processing.
+ */
LDKChannelMonitorUpdateErr_PermanentFailure,
; static native void init();
static { init(); }
* estimation.
*/
public enum ConfirmationTarget {
+ /**
+ * We are happy with this transaction confirming slowly when feerate drops some.
+ */
LDKConfirmationTarget_Background,
+ /**
+ * We'd like this transaction to confirm without major delay, but 12-18 blocks is fine.
+ */
LDKConfirmationTarget_Normal,
+ /**
+ * We'd like this transaction to confirm in the next few blocks.
+ */
LDKConfirmationTarget_HighPriority,
; static native void init();
static { init(); }
* Errors that may occur when constructing a new `RawInvoice` or `Invoice`
*/
public enum CreationError {
+ /**
+ * The supplied description string was longer than 639 __bytes__ (see [`Description::new(...)`](./struct.Description.html#method.new))
+ */
LDKCreationError_DescriptionTooLong,
+ /**
+ * The specified route has too many hops and can't be encoded
+ */
LDKCreationError_RouteTooLong,
+ /**
+ * The unix timestamp of the supplied date is <0 or can't be represented as `SystemTime`
+ */
LDKCreationError_TimestampOutOfBounds,
+ /**
+ * The supplied expiry time could cause an overflow if added to a `PositiveTimestamp`
+ */
LDKCreationError_ExpiryTimeOutOfBounds,
; static native void init();
static { init(); }
* Enum representing the crypto currencies (or networks) supported by this library
*/
public enum Currency {
+ /**
+ * Bitcoin mainnet
+ */
LDKCurrency_Bitcoin,
+ /**
+ * Bitcoin testnet
+ */
LDKCurrency_BitcoinTestnet,
+ /**
+ * Bitcoin regtest
+ */
LDKCurrency_Regtest,
+ /**
+ * Bitcoin simnet
+ */
LDKCurrency_Simnet,
+ /**
+ * Bitcoin signet
+ */
LDKCurrency_Signet,
; static native void init();
static { init(); }
* An enum representing the available verbosity levels of the logger.
*/
public enum Level {
+ /**
+ * Designates very low priority, often extremely verbose, information
+ */
LDKLevel_Trace,
+ /**
+ * Designates lower priority information
+ */
LDKLevel_Debug,
+ /**
+ * Designates useful information
+ */
LDKLevel_Info,
+ /**
+ * Designates hazardous situations
+ */
LDKLevel_Warn,
+ /**
+ * Designates very serious errors
+ */
LDKLevel_Error,
; static native void init();
static { init(); }
* An enum representing the possible Bitcoin or test networks which we can run on
*/
public enum Network {
+ /**
+ * The main Bitcoin blockchain.
+ */
LDKNetwork_Bitcoin,
+ /**
+ * The testnet3 blockchain.
+ */
LDKNetwork_Testnet,
+ /**
+ * A local test blockchain.
+ */
LDKNetwork_Regtest,
+ /**
+ * A blockchain on which blocks are signed instead of mined.
+ */
LDKNetwork_Signet,
; static native void init();
static { init(); }
* Represents an error returned from libsecp256k1 during validation of some secp256k1 data
*/
public enum Secp256k1Error {
+ /**
+ * Signature failed verification
+ */
LDKSecp256k1Error_IncorrectSignature,
+ /**
+ * Badly sized message ("messages" are actually fixed-sized digests; see the MESSAGE_SIZE constant)
+ */
LDKSecp256k1Error_InvalidMessage,
+ /**
+ * Bad public key
+ */
LDKSecp256k1Error_InvalidPublicKey,
+ /**
+ * Bad signature
+ */
LDKSecp256k1Error_InvalidSignature,
+ /**
+ * Bad secret key
+ */
LDKSecp256k1Error_InvalidSecretKey,
+ /**
+ * Bad recovery id
+ */
LDKSecp256k1Error_InvalidRecoveryId,
+ /**
+ * Invalid tweak for add_assign or mul_assign
+ */
LDKSecp256k1Error_InvalidTweak,
+ /**
+ * tweak_add_check failed on an xonly public key
+ */
LDKSecp256k1Error_TweakCheckFailed,
+ /**
+ * Didn't pass enough memory to context creation with preallocated memory
+ */
LDKSecp256k1Error_NotEnoughMemory,
; static native void init();
static { init(); }
* requirements sections in BOLT #11
*/
public enum SemanticError {
+ /**
+ * The invoice is missing the mandatory payment hash
+ */
LDKSemanticError_NoPaymentHash,
+ /**
+ * The invoice has multiple payment hashes which isn't allowed
+ */
LDKSemanticError_MultiplePaymentHashes,
+ /**
+ * No description or description hash are part of the invoice
+ */
LDKSemanticError_NoDescription,
+ /**
+ * The invoice contains multiple descriptions and/or description hashes which isn't allowed
+ */
LDKSemanticError_MultipleDescriptions,
+ /**
+ * The invoice is missing the mandatory payment secret, which all modern lightning nodes
+ * should provide.
+ */
LDKSemanticError_NoPaymentSecret,
+ /**
+ * The invoice contains multiple payment secrets
+ */
LDKSemanticError_MultiplePaymentSecrets,
+ /**
+ * The invoice's features are invalid
+ */
LDKSemanticError_InvalidFeatures,
+ /**
+ * The recovery id doesn't fit the signature/pub key
+ */
LDKSemanticError_InvalidRecoveryId,
+ /**
+ * The invoice's signature is invalid
+ */
LDKSemanticError_InvalidSignature,
+ /**
+ * The invoice's amount was not a whole number of millisatoshis
+ */
LDKSemanticError_ImpreciseAmount,
; static native void init();
static { init(); }
* SI prefixes for the human readable part
*/
public enum SiPrefix {
+ /**
+ * 10^-3
+ */
LDKSiPrefix_Milli,
+ /**
+ * 10^-6
+ */
LDKSiPrefix_Micro,
+ /**
+ * 10^-9
+ */
LDKSiPrefix_Nano,
+ /**
+ * 10^-12
+ */
LDKSiPrefix_Pico,
; static native void init();
static { init(); }
static { Secp256k1Error.values(); /* Force enum statics to run */ }
static { SemanticError.values(); /* Force enum statics to run */ }
static { SiPrefix.values(); /* Force enum statics to run */ }
- public static native long LDKCVec_u8Z_new(byte[] elems);
// struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)
public static native byte[] TxOut_get_script_pubkey(long thing);
// uint64_t TxOut_get_value (struct LDKTxOut* thing)
public static native long TxOut_get_value(long thing);
- public static native boolean LDKCResult_SecretKeyErrorZ_result_ok(long arg);
public static native byte[] LDKCResult_SecretKeyErrorZ_get_ok(long arg);
public static native Secp256k1Error LDKCResult_SecretKeyErrorZ_get_err(long arg);
- public static native boolean LDKCResult_PublicKeyErrorZ_result_ok(long arg);
public static native byte[] LDKCResult_PublicKeyErrorZ_get_ok(long arg);
public static native Secp256k1Error LDKCResult_PublicKeyErrorZ_get_err(long arg);
- public static native boolean LDKCResult_TxCreationKeysDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_TxCreationKeysDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_TxCreationKeysDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelPublicKeysDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_ChannelPublicKeysDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_ChannelPublicKeysDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_TxCreationKeysErrorZ_result_ok(long arg);
public static native long LDKCResult_TxCreationKeysErrorZ_get_ok(long arg);
public static native Secp256k1Error LDKCResult_TxCreationKeysErrorZ_get_err(long arg);
public static class LDKCOption_u32Z {
}
static { LDKCOption_u32Z.init(); }
public static native LDKCOption_u32Z LDKCOption_u32Z_ref_from_ptr(long ptr);
- public static native boolean LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelTransactionParametersDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_ChannelTransactionParametersDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_ChannelTransactionParametersDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_HolderCommitmentTransactionDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_HolderCommitmentTransactionDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_BuiltCommitmentTransactionDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_TrustedClosingTransactionNoneZ_result_ok(long arg);
public static native long LDKCResult_TrustedClosingTransactionNoneZ_get_ok(long arg);
public static native void LDKCResult_TrustedClosingTransactionNoneZ_get_err(long arg);
- public static native boolean LDKCResult_CommitmentTransactionDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_CommitmentTransactionDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_CommitmentTransactionDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_TrustedCommitmentTransactionNoneZ_result_ok(long arg);
public static native long LDKCResult_TrustedCommitmentTransactionNoneZ_get_ok(long arg);
public static native void LDKCResult_TrustedCommitmentTransactionNoneZ_get_err(long arg);
- public static native boolean LDKCResult_CVec_SignatureZNoneZ_result_ok(long arg);
public static native byte[][] LDKCResult_CVec_SignatureZNoneZ_get_ok(long arg);
public static native void LDKCResult_CVec_SignatureZNoneZ_get_err(long arg);
- public static native boolean LDKCResult_ShutdownScriptDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_ShutdownScriptDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_ShutdownScriptDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ShutdownScriptInvalidShutdownScriptZ_result_ok(long arg);
public static native long LDKCResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(long arg);
public static native long LDKCResult_ShutdownScriptInvalidShutdownScriptZ_get_err(long arg);
- public static native boolean LDKCResult_NoneErrorZ_result_ok(long arg);
public static native void LDKCResult_NoneErrorZ_get_ok(long arg);
public static native IOError LDKCResult_NoneErrorZ_get_err(long arg);
- public static native boolean LDKCResult_RouteHopDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_RouteHopDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_RouteHopDecodeErrorZ_get_err(long arg);
- public static native long LDKCVec_RouteHopZ_new(long[] elems);
- public static native boolean LDKCResult_RouteDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_RouteDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_RouteDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_RouteParametersDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_RouteParametersDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_RouteParametersDecodeErrorZ_get_err(long arg);
- public static native long LDKCVec_RouteHintZ_new(long[] elems);
public static class LDKCOption_u64Z {
private LDKCOption_u64Z() {}
public final static class Some extends LDKCOption_u64Z {
}
static { LDKCOption_u64Z.init(); }
public static native LDKCOption_u64Z LDKCOption_u64Z_ref_from_ptr(long ptr);
- public static native boolean LDKCResult_PayeeDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_PayeeDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_PayeeDecodeErrorZ_get_err(long arg);
- public static native long LDKCVec_RouteHintHopZ_new(long[] elems);
- public static native boolean LDKCResult_RouteHintDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_RouteHintDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_RouteHintDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_RouteHintHopDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_RouteHintHopDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_RouteHintHopDecodeErrorZ_get_err(long arg);
- public static native long LDKCVec_ChannelDetailsZ_new(long[] elems);
- public static native boolean LDKCResult_RouteLightningErrorZ_result_ok(long arg);
public static native long LDKCResult_RouteLightningErrorZ_get_ok(long arg);
public static native long LDKCResult_RouteLightningErrorZ_get_err(long arg);
- public static native boolean LDKCResult_TxOutAccessErrorZ_result_ok(long arg);
public static native long LDKCResult_TxOutAccessErrorZ_get_ok(long arg);
public static native AccessError LDKCResult_TxOutAccessErrorZ_get_err(long arg);
// uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR tuple);
public static native long C2Tuple_usizeTransactionZ_get_a(long tuple);
// struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR tuple);
public static native byte[] C2Tuple_usizeTransactionZ_get_b(long tuple);
- public static native long LDKCVec_C2Tuple_usizeTransactionZZ_new(long[] elems);
- public static native boolean LDKCResult_NoneChannelMonitorUpdateErrZ_result_ok(long arg);
public static native void LDKCResult_NoneChannelMonitorUpdateErrZ_get_ok(long arg);
public static native ChannelMonitorUpdateErr LDKCResult_NoneChannelMonitorUpdateErrZ_get_err(long arg);
public static class LDKMonitorEvent {
}
static { LDKMonitorEvent.init(); }
public static native LDKMonitorEvent LDKMonitorEvent_ref_from_ptr(long ptr);
- public static native long LDKCVec_MonitorEventZ_new(long[] elems);
public static class LDKCOption_C2Tuple_usizeTransactionZZ {
private LDKCOption_C2Tuple_usizeTransactionZZ() {}
public final static class Some extends LDKCOption_C2Tuple_usizeTransactionZZ {
}
static { LDKCOption_C2Tuple_usizeTransactionZZ.init(); }
public static native LDKCOption_C2Tuple_usizeTransactionZZ LDKCOption_C2Tuple_usizeTransactionZZ_ref_from_ptr(long ptr);
+ public static class LDKClosureReason {
+ private LDKClosureReason() {}
+ public final static class CounterpartyForceClosed extends LDKClosureReason {
+ public String peer_msg;
+ CounterpartyForceClosed(String peer_msg) { this.peer_msg = peer_msg; }
+ }
+ public final static class HolderForceClosed extends LDKClosureReason {
+ HolderForceClosed() { }
+ }
+ public final static class CooperativeClosure extends LDKClosureReason {
+ CooperativeClosure() { }
+ }
+ public final static class CommitmentTxConfirmed extends LDKClosureReason {
+ CommitmentTxConfirmed() { }
+ }
+ public final static class ProcessingError extends LDKClosureReason {
+ public String err;
+ ProcessingError(String err) { this.err = err; }
+ }
+ public final static class DisconnectedPeer extends LDKClosureReason {
+ DisconnectedPeer() { }
+ }
+ public final static class OutdatedChannelManager extends LDKClosureReason {
+ OutdatedChannelManager() { }
+ }
+ static native void init();
+ }
+ static { LDKClosureReason.init(); }
+ public static native LDKClosureReason LDKClosureReason_ref_from_ptr(long ptr);
+ public static class LDKCOption_ClosureReasonZ {
+ private LDKCOption_ClosureReasonZ() {}
+ public final static class Some extends LDKCOption_ClosureReasonZ {
+ public long some;
+ Some(long some) { this.some = some; }
+ }
+ public final static class None extends LDKCOption_ClosureReasonZ {
+ None() { }
+ }
+ static native void init();
+ }
+ static { LDKCOption_ClosureReasonZ.init(); }
+ public static native LDKCOption_ClosureReasonZ LDKCOption_ClosureReasonZ_ref_from_ptr(long ptr);
+ public static native long LDKCResult_COption_ClosureReasonZDecodeErrorZ_get_ok(long arg);
+ public static native long LDKCResult_COption_ClosureReasonZDecodeErrorZ_get_err(long arg);
public static class LDKNetworkUpdate {
private LDKNetworkUpdate() {}
public final static class ChannelUpdateMessage extends LDKNetworkUpdate {
}
static { LDKSpendableOutputDescriptor.init(); }
public static native LDKSpendableOutputDescriptor LDKSpendableOutputDescriptor_ref_from_ptr(long ptr);
- public static native long LDKCVec_SpendableOutputDescriptorZ_new(long[] elems);
+ public static class LDKPaymentPurpose {
+ private LDKPaymentPurpose() {}
+ public final static class InvoicePayment extends LDKPaymentPurpose {
+ public byte[] payment_preimage;
+ public byte[] payment_secret;
+ public long user_payment_id;
+ InvoicePayment(byte[] payment_preimage, byte[] payment_secret, long user_payment_id) { this.payment_preimage = payment_preimage; this.payment_secret = payment_secret; this.user_payment_id = user_payment_id; }
+ }
+ public final static class SpontaneousPayment extends LDKPaymentPurpose {
+ public byte[] spontaneous_payment;
+ SpontaneousPayment(byte[] spontaneous_payment) { this.spontaneous_payment = spontaneous_payment; }
+ }
+ static native void init();
+ }
+ static { LDKPaymentPurpose.init(); }
+ public static native LDKPaymentPurpose LDKPaymentPurpose_ref_from_ptr(long ptr);
+ public static class LDKEvent {
+ private LDKEvent() {}
+ public final static class FundingGenerationReady extends LDKEvent {
+ public byte[] temporary_channel_id;
+ public long channel_value_satoshis;
+ public byte[] output_script;
+ public long user_channel_id;
+ FundingGenerationReady(byte[] temporary_channel_id, long channel_value_satoshis, byte[] output_script, long user_channel_id) { this.temporary_channel_id = temporary_channel_id; this.channel_value_satoshis = channel_value_satoshis; this.output_script = output_script; this.user_channel_id = user_channel_id; }
+ }
+ public final static class PaymentReceived extends LDKEvent {
+ public byte[] payment_hash;
+ public long amt;
+ public long purpose;
+ PaymentReceived(byte[] payment_hash, long amt, long purpose) { this.payment_hash = payment_hash; this.amt = amt; this.purpose = purpose; }
+ }
+ public final static class PaymentSent extends LDKEvent {
+ public byte[] payment_id;
+ public byte[] payment_preimage;
+ public byte[] payment_hash;
+ public long fee_paid_msat;
+ PaymentSent(byte[] payment_id, byte[] payment_preimage, byte[] payment_hash, long fee_paid_msat) { this.payment_id = payment_id; this.payment_preimage = payment_preimage; this.payment_hash = payment_hash; this.fee_paid_msat = fee_paid_msat; }
+ }
+ public final static class PaymentPathFailed extends LDKEvent {
+ public byte[] payment_id;
+ public byte[] payment_hash;
+ public boolean rejected_by_dest;
+ public long network_update;
+ public boolean all_paths_failed;
+ public long[] path;
+ public long short_channel_id;
+ public long retry;
+ PaymentPathFailed(byte[] payment_id, byte[] payment_hash, boolean rejected_by_dest, long network_update, boolean all_paths_failed, long[] path, long short_channel_id, long retry) { this.payment_id = payment_id; this.payment_hash = payment_hash; this.rejected_by_dest = rejected_by_dest; this.network_update = network_update; this.all_paths_failed = all_paths_failed; this.path = path; this.short_channel_id = short_channel_id; this.retry = retry; }
+ }
+ public final static class PendingHTLCsForwardable extends LDKEvent {
+ public long time_forwardable;
+ PendingHTLCsForwardable(long time_forwardable) { this.time_forwardable = time_forwardable; }
+ }
+ public final static class SpendableOutputs extends LDKEvent {
+ public long[] outputs;
+ SpendableOutputs(long[] outputs) { this.outputs = outputs; }
+ }
+ public final static class PaymentForwarded extends LDKEvent {
+ public long fee_earned_msat;
+ public boolean claim_from_onchain_tx;
+ PaymentForwarded(long fee_earned_msat, boolean claim_from_onchain_tx) { this.fee_earned_msat = fee_earned_msat; this.claim_from_onchain_tx = claim_from_onchain_tx; }
+ }
+ public final static class ChannelClosed extends LDKEvent {
+ public byte[] channel_id;
+ public long user_channel_id;
+ public long reason;
+ ChannelClosed(byte[] channel_id, long user_channel_id, long reason) { this.channel_id = channel_id; this.user_channel_id = user_channel_id; this.reason = reason; }
+ }
+ public final static class DiscardFunding extends LDKEvent {
+ public byte[] channel_id;
+ public byte[] transaction;
+ DiscardFunding(byte[] channel_id, byte[] transaction) { this.channel_id = channel_id; this.transaction = transaction; }
+ }
+ static native void init();
+ }
+ static { LDKEvent.init(); }
+ public static native LDKEvent LDKEvent_ref_from_ptr(long ptr);
+ public static class LDKCOption_EventZ {
+ private LDKCOption_EventZ() {}
+ public final static class Some extends LDKCOption_EventZ {
+ public long some;
+ Some(long some) { this.some = some; }
+ }
+ public final static class None extends LDKCOption_EventZ {
+ None() { }
+ }
+ static native void init();
+ }
+ static { LDKCOption_EventZ.init(); }
+ public static native LDKCOption_EventZ LDKCOption_EventZ_ref_from_ptr(long ptr);
+ public static native long LDKCResult_COption_EventZDecodeErrorZ_get_ok(long arg);
+ public static native long LDKCResult_COption_EventZDecodeErrorZ_get_err(long arg);
public static class LDKErrorAction {
private LDKErrorAction() {}
public final static class DisconnectPeer extends LDKErrorAction {
}
static { LDKMessageSendEvent.init(); }
public static native LDKMessageSendEvent LDKMessageSendEvent_ref_from_ptr(long ptr);
- public static native long LDKCVec_MessageSendEventZ_new(long[] elems);
- public static native boolean LDKCResult_InitFeaturesDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_InitFeaturesDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_InitFeaturesDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NodeFeaturesDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_NodeFeaturesDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_NodeFeaturesDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelFeaturesDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_ChannelFeaturesDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_ChannelFeaturesDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_InvoiceFeaturesDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_InvoiceFeaturesDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_InvoiceFeaturesDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ScoringParametersDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_ScoringParametersDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_ScoringParametersDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ScorerDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_ScorerDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_ScorerDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_SpendableOutputDescriptorDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_SpendableOutputDescriptorDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NoneNoneZ_result_ok(long arg);
public static native void LDKCResult_NoneNoneZ_get_ok(long arg);
public static native void LDKCResult_NoneNoneZ_get_err(long arg);
// struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR tuple);
public static native byte[] C2Tuple_SignatureCVec_SignatureZZ_get_a(long tuple);
// struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR tuple);
public static native byte[][] C2Tuple_SignatureCVec_SignatureZZ_get_b(long tuple);
- public static native boolean LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_result_ok(long arg);
public static native long LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(long arg);
public static native void LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(long arg);
- public static native boolean LDKCResult_SignatureNoneZ_result_ok(long arg);
public static native byte[] LDKCResult_SignatureNoneZ_get_ok(long arg);
public static native void LDKCResult_SignatureNoneZ_get_err(long arg);
public interface LDKBaseSign {
public static native long LDKSign_get_BaseSign(long arg);
// LDKCVec_u8Z Sign_write LDKSign *NONNULL_PTR this_arg
public static native byte[] Sign_write(long this_arg);
- public static native boolean LDKCResult_SignDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_SignDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_SignDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_RecoverableSignatureNoneZ_result_ok(long arg);
public static native byte[] LDKCResult_RecoverableSignatureNoneZ_get_ok(long arg);
public static native void LDKCResult_RecoverableSignatureNoneZ_get_err(long arg);
- public static native boolean LDKCResult_CVec_CVec_u8ZZNoneZ_result_ok(long arg);
public static native byte[][] LDKCResult_CVec_CVec_u8ZZNoneZ_get_ok(long arg);
public static native void LDKCResult_CVec_CVec_u8ZZNoneZ_get_err(long arg);
- public static native boolean LDKCResult_InMemorySignerDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_InMemorySignerDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_InMemorySignerDecodeErrorZ_get_err(long arg);
- public static native long LDKCVec_TxOutZ_new(long[] elems);
- public static native boolean LDKCResult_TransactionNoneZ_result_ok(long arg);
public static native byte[] LDKCResult_TransactionNoneZ_get_ok(long arg);
public static native void LDKCResult_TransactionNoneZ_get_err(long arg);
// struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR tuple);
public static native byte[] C2Tuple_BlockHashChannelMonitorZ_get_a(long tuple);
// struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR tuple);
public static native long C2Tuple_BlockHashChannelMonitorZ_get_b(long tuple);
- public static native long LDKCVec_C2Tuple_BlockHashChannelMonitorZZ_new(long[] elems);
- public static native boolean LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_result_ok(long arg);
public static native long[] LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_get_ok(long arg);
public static native IOError LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_get_err(long arg);
public static class LDKCOption_u16Z {
}
static { LDKAPIError.init(); }
public static native LDKAPIError LDKAPIError_ref_from_ptr(long ptr);
- public static native boolean LDKCResult_NoneAPIErrorZ_result_ok(long arg);
public static native void LDKCResult_NoneAPIErrorZ_get_ok(long arg);
public static native long LDKCResult_NoneAPIErrorZ_get_err(long arg);
- public static native long LDKCVec_CResult_NoneAPIErrorZZ_new(long[] elems);
- public static native long LDKCVec_APIErrorZ_new(long[] elems);
- public static native boolean LDKCResult__u832APIErrorZ_result_ok(long arg);
public static native byte[] LDKCResult__u832APIErrorZ_get_ok(long arg);
public static native long LDKCResult__u832APIErrorZ_get_err(long arg);
public static class LDKPaymentSendFailure {
}
static { LDKPaymentSendFailure.init(); }
public static native LDKPaymentSendFailure LDKPaymentSendFailure_ref_from_ptr(long ptr);
- public static native boolean LDKCResult_PaymentIdPaymentSendFailureZ_result_ok(long arg);
public static native byte[] LDKCResult_PaymentIdPaymentSendFailureZ_get_ok(long arg);
public static native long LDKCResult_PaymentIdPaymentSendFailureZ_get_err(long arg);
- public static native boolean LDKCResult_NonePaymentSendFailureZ_result_ok(long arg);
public static native void LDKCResult_NonePaymentSendFailureZ_get_ok(long arg);
public static native long LDKCResult_NonePaymentSendFailureZ_get_err(long arg);
// struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR tuple);
public static native byte[] C2Tuple_PaymentHashPaymentIdZ_get_a(long tuple);
// struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR tuple);
public static native byte[] C2Tuple_PaymentHashPaymentIdZ_get_b(long tuple);
- public static native boolean LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_result_ok(long arg);
public static native long LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(long arg);
public static native long LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(long arg);
public static class LDKNetAddress {
}
static { LDKNetAddress.init(); }
public static native LDKNetAddress LDKNetAddress_ref_from_ptr(long ptr);
- public static native long LDKCVec_NetAddressZ_new(long[] elems);
// struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR tuple);
public static native byte[] C2Tuple_PaymentHashPaymentSecretZ_get_a(long tuple);
// struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR tuple);
public static native byte[] C2Tuple_PaymentHashPaymentSecretZ_get_b(long tuple);
- public static native boolean LDKCResult_PaymentSecretAPIErrorZ_result_ok(long arg);
public static native byte[] LDKCResult_PaymentSecretAPIErrorZ_get_ok(long arg);
public static native long LDKCResult_PaymentSecretAPIErrorZ_get_err(long arg);
- public static native long LDKCVec_ChannelMonitorZ_new(long[] elems);
public interface LDKWatch {
long watch_channel(long funding_txo, long monitor);
long update_channel(long funding_txo, long update);
// uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
public static native int FeeEstimator_get_est_sat_per_1000_weight(long this_arg, ConfirmationTarget confirmation_target);
public interface LDKLogger {
- void log(String record);
+ void log(long record);
}
public static native long LDKLogger_new(LDKLogger impl);
// struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR tuple);
public static native byte[] C2Tuple_BlockHashChannelManagerZ_get_a(long tuple);
// struct LDKChannelManager *C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR tuple);
public static native long C2Tuple_BlockHashChannelManagerZ_get_b(long tuple);
- public static native boolean LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelConfigDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_ChannelConfigDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_ChannelConfigDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_OutPointDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_OutPointDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_OutPointDecodeErrorZ_get_err(long arg);
public interface LDKType {
}
static { LDKCOption_TypeZ.init(); }
public static native LDKCOption_TypeZ LDKCOption_TypeZ_ref_from_ptr(long ptr);
- public static native boolean LDKCResult_COption_TypeZDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_COption_TypeZDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_COption_TypeZDecodeErrorZ_get_err(long arg);
public static class LDKPaymentError {
}
static { LDKPaymentError.init(); }
public static native LDKPaymentError LDKPaymentError_ref_from_ptr(long ptr);
- public static native boolean LDKCResult_PaymentIdPaymentErrorZ_result_ok(long arg);
public static native byte[] LDKCResult_PaymentIdPaymentErrorZ_get_ok(long arg);
public static native long LDKCResult_PaymentIdPaymentErrorZ_get_err(long arg);
- public static native boolean LDKCResult_SiPrefixNoneZ_result_ok(long arg);
public static native SiPrefix LDKCResult_SiPrefixNoneZ_get_ok(long arg);
public static native void LDKCResult_SiPrefixNoneZ_get_err(long arg);
- public static native boolean LDKCResult_InvoiceNoneZ_result_ok(long arg);
public static native long LDKCResult_InvoiceNoneZ_get_ok(long arg);
public static native void LDKCResult_InvoiceNoneZ_get_err(long arg);
- public static native boolean LDKCResult_SignedRawInvoiceNoneZ_result_ok(long arg);
public static native long LDKCResult_SignedRawInvoiceNoneZ_get_ok(long arg);
public static native void LDKCResult_SignedRawInvoiceNoneZ_get_err(long arg);
// struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR tuple);
public static native byte[] C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(long tuple);
// struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR tuple);
public static native long C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(long tuple);
- public static native boolean LDKCResult_PayeePubKeyErrorZ_result_ok(long arg);
public static native long LDKCResult_PayeePubKeyErrorZ_get_ok(long arg);
public static native Secp256k1Error LDKCResult_PayeePubKeyErrorZ_get_err(long arg);
- public static native long LDKCVec_PrivateRouteZ_new(long[] elems);
- public static native boolean LDKCResult_PositiveTimestampCreationErrorZ_result_ok(long arg);
public static native long LDKCResult_PositiveTimestampCreationErrorZ_get_ok(long arg);
public static native CreationError LDKCResult_PositiveTimestampCreationErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NoneSemanticErrorZ_result_ok(long arg);
public static native void LDKCResult_NoneSemanticErrorZ_get_ok(long arg);
public static native SemanticError LDKCResult_NoneSemanticErrorZ_get_err(long arg);
- public static native boolean LDKCResult_InvoiceSemanticErrorZ_result_ok(long arg);
public static native long LDKCResult_InvoiceSemanticErrorZ_get_ok(long arg);
public static native SemanticError LDKCResult_InvoiceSemanticErrorZ_get_err(long arg);
- public static native boolean LDKCResult_DescriptionCreationErrorZ_result_ok(long arg);
public static native long LDKCResult_DescriptionCreationErrorZ_get_ok(long arg);
public static native CreationError LDKCResult_DescriptionCreationErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ExpiryTimeCreationErrorZ_result_ok(long arg);
public static native long LDKCResult_ExpiryTimeCreationErrorZ_get_ok(long arg);
public static native CreationError LDKCResult_ExpiryTimeCreationErrorZ_get_err(long arg);
- public static native boolean LDKCResult_PrivateRouteCreationErrorZ_result_ok(long arg);
public static native long LDKCResult_PrivateRouteCreationErrorZ_get_ok(long arg);
public static native CreationError LDKCResult_PrivateRouteCreationErrorZ_get_err(long arg);
- public static native boolean LDKCResult_StringErrorZ_result_ok(long arg);
public static native String LDKCResult_StringErrorZ_get_ok(long arg);
public static native Secp256k1Error LDKCResult_StringErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelMonitorUpdateDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_ChannelMonitorUpdateDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_HTLCUpdateDecodeErrorZ_result_ok(long arg);
+ public static class LDKCOption_MonitorEventZ {
+ private LDKCOption_MonitorEventZ() {}
+ public final static class Some extends LDKCOption_MonitorEventZ {
+ public long some;
+ Some(long some) { this.some = some; }
+ }
+ public final static class None extends LDKCOption_MonitorEventZ {
+ None() { }
+ }
+ static native void init();
+ }
+ static { LDKCOption_MonitorEventZ.init(); }
+ public static native LDKCOption_MonitorEventZ LDKCOption_MonitorEventZ_ref_from_ptr(long ptr);
+ public static native long LDKCResult_COption_MonitorEventZDecodeErrorZ_get_ok(long arg);
+ public static native long LDKCResult_COption_MonitorEventZDecodeErrorZ_get_err(long arg);
public static native long LDKCResult_HTLCUpdateDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_HTLCUpdateDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NoneMonitorUpdateErrorZ_result_ok(long arg);
public static native void LDKCResult_NoneMonitorUpdateErrorZ_get_ok(long arg);
public static native long LDKCResult_NoneMonitorUpdateErrorZ_get_err(long arg);
// struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR tuple);
public static native int C2Tuple_u32ScriptZ_get_a(long tuple);
// struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR tuple);
public static native byte[] C2Tuple_u32ScriptZ_get_b(long tuple);
- public static native long LDKCVec_C2Tuple_u32ScriptZZ_new(long[] elems);
// struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR tuple);
public static native byte[] C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(long tuple);
// struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR tuple);
public static native long[] C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(long tuple);
- public static native long LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_new(long[] elems);
- public static class LDKPaymentPurpose {
- private LDKPaymentPurpose() {}
- public final static class InvoicePayment extends LDKPaymentPurpose {
- public byte[] payment_preimage;
- public byte[] payment_secret;
- public long user_payment_id;
- InvoicePayment(byte[] payment_preimage, byte[] payment_secret, long user_payment_id) { this.payment_preimage = payment_preimage; this.payment_secret = payment_secret; this.user_payment_id = user_payment_id; }
- }
- public final static class SpontaneousPayment extends LDKPaymentPurpose {
- public byte[] spontaneous_payment;
- SpontaneousPayment(byte[] spontaneous_payment) { this.spontaneous_payment = spontaneous_payment; }
- }
- static native void init();
- }
- static { LDKPaymentPurpose.init(); }
- public static native LDKPaymentPurpose LDKPaymentPurpose_ref_from_ptr(long ptr);
- public static class LDKClosureReason {
- private LDKClosureReason() {}
- public final static class CounterpartyForceClosed extends LDKClosureReason {
- public String peer_msg;
- CounterpartyForceClosed(String peer_msg) { this.peer_msg = peer_msg; }
- }
- public final static class HolderForceClosed extends LDKClosureReason {
- HolderForceClosed() { }
- }
- public final static class CooperativeClosure extends LDKClosureReason {
- CooperativeClosure() { }
- }
- public final static class CommitmentTxConfirmed extends LDKClosureReason {
- CommitmentTxConfirmed() { }
- }
- public final static class ProcessingError extends LDKClosureReason {
- public String err;
- ProcessingError(String err) { this.err = err; }
- }
- public final static class DisconnectedPeer extends LDKClosureReason {
- DisconnectedPeer() { }
- }
- public final static class OutdatedChannelManager extends LDKClosureReason {
- OutdatedChannelManager() { }
- }
- static native void init();
- }
- static { LDKClosureReason.init(); }
- public static native LDKClosureReason LDKClosureReason_ref_from_ptr(long ptr);
- public static class LDKEvent {
- private LDKEvent() {}
- public final static class FundingGenerationReady extends LDKEvent {
- public byte[] temporary_channel_id;
- public long channel_value_satoshis;
- public byte[] output_script;
- public long user_channel_id;
- FundingGenerationReady(byte[] temporary_channel_id, long channel_value_satoshis, byte[] output_script, long user_channel_id) { this.temporary_channel_id = temporary_channel_id; this.channel_value_satoshis = channel_value_satoshis; this.output_script = output_script; this.user_channel_id = user_channel_id; }
- }
- public final static class PaymentReceived extends LDKEvent {
- public byte[] payment_hash;
- public long amt;
- public long purpose;
- PaymentReceived(byte[] payment_hash, long amt, long purpose) { this.payment_hash = payment_hash; this.amt = amt; this.purpose = purpose; }
- }
- public final static class PaymentSent extends LDKEvent {
- public byte[] payment_id;
- public byte[] payment_preimage;
- public byte[] payment_hash;
- public long fee_paid_msat;
- PaymentSent(byte[] payment_id, byte[] payment_preimage, byte[] payment_hash, long fee_paid_msat) { this.payment_id = payment_id; this.payment_preimage = payment_preimage; this.payment_hash = payment_hash; this.fee_paid_msat = fee_paid_msat; }
- }
- public final static class PaymentPathFailed extends LDKEvent {
- public byte[] payment_id;
- public byte[] payment_hash;
- public boolean rejected_by_dest;
- public long network_update;
- public boolean all_paths_failed;
- public long[] path;
- public long short_channel_id;
- public long retry;
- PaymentPathFailed(byte[] payment_id, byte[] payment_hash, boolean rejected_by_dest, long network_update, boolean all_paths_failed, long[] path, long short_channel_id, long retry) { this.payment_id = payment_id; this.payment_hash = payment_hash; this.rejected_by_dest = rejected_by_dest; this.network_update = network_update; this.all_paths_failed = all_paths_failed; this.path = path; this.short_channel_id = short_channel_id; this.retry = retry; }
- }
- public final static class PendingHTLCsForwardable extends LDKEvent {
- public long time_forwardable;
- PendingHTLCsForwardable(long time_forwardable) { this.time_forwardable = time_forwardable; }
- }
- public final static class SpendableOutputs extends LDKEvent {
- public long[] outputs;
- SpendableOutputs(long[] outputs) { this.outputs = outputs; }
- }
- public final static class PaymentForwarded extends LDKEvent {
- public long fee_earned_msat;
- public boolean claim_from_onchain_tx;
- PaymentForwarded(long fee_earned_msat, boolean claim_from_onchain_tx) { this.fee_earned_msat = fee_earned_msat; this.claim_from_onchain_tx = claim_from_onchain_tx; }
- }
- public final static class ChannelClosed extends LDKEvent {
- public byte[] channel_id;
- public long user_channel_id;
- public long reason;
- ChannelClosed(byte[] channel_id, long user_channel_id, long reason) { this.channel_id = channel_id; this.user_channel_id = user_channel_id; this.reason = reason; }
- }
- public final static class DiscardFunding extends LDKEvent {
- public byte[] channel_id;
- public byte[] transaction;
- DiscardFunding(byte[] channel_id, byte[] transaction) { this.channel_id = channel_id; this.transaction = transaction; }
- }
- static native void init();
- }
- static { LDKEvent.init(); }
- public static native LDKEvent LDKEvent_ref_from_ptr(long ptr);
- public static native long LDKCVec_EventZ_new(long[] elems);
// uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR tuple);
public static native int C2Tuple_u32TxOutZ_get_a(long tuple);
// struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR tuple);
public static native long C2Tuple_u32TxOutZ_get_b(long tuple);
- public static native long LDKCVec_C2Tuple_u32TxOutZZ_new(long[] elems);
// struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR tuple);
public static native byte[] C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(long tuple);
// struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR tuple);
public static native long[] C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(long tuple);
- public static native long LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_new(long[] elems);
public static class LDKBalance {
private LDKBalance() {}
public final static class ClaimableOnChannelClose extends LDKBalance {
}
static { LDKBalance.init(); }
public static native LDKBalance LDKBalance_ref_from_ptr(long ptr);
- public static native long LDKCVec_BalanceZ_new(long[] elems);
- public static native boolean LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NoneLightningErrorZ_result_ok(long arg);
public static native void LDKCResult_NoneLightningErrorZ_get_ok(long arg);
public static native long LDKCResult_NoneLightningErrorZ_get_err(long arg);
// struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR tuple);
public static native byte[] C2Tuple_PublicKeyTypeZ_get_a(long tuple);
// struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR tuple);
public static native long C2Tuple_PublicKeyTypeZ_get_b(long tuple);
- public static native long LDKCVec_C2Tuple_PublicKeyTypeZZ_new(long[] elems);
- public static native boolean LDKCResult_boolLightningErrorZ_result_ok(long arg);
public static native boolean LDKCResult_boolLightningErrorZ_get_ok(long arg);
public static native long LDKCResult_boolLightningErrorZ_get_err(long arg);
// struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR tuple);
public static native long C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(long tuple);
// struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR tuple);
public static native long C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(long tuple);
- public static native long LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_new(long[] elems);
- public static native long LDKCVec_NodeAnnouncementZ_new(long[] elems);
- public static native boolean LDKCResult_CVec_u8ZPeerHandleErrorZ_result_ok(long arg);
public static native byte[] LDKCResult_CVec_u8ZPeerHandleErrorZ_get_ok(long arg);
public static native long LDKCResult_CVec_u8ZPeerHandleErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NonePeerHandleErrorZ_result_ok(long arg);
public static native void LDKCResult_NonePeerHandleErrorZ_get_ok(long arg);
public static native long LDKCResult_NonePeerHandleErrorZ_get_err(long arg);
- public static native boolean LDKCResult_boolPeerHandleErrorZ_result_ok(long arg);
public static native boolean LDKCResult_boolPeerHandleErrorZ_get_ok(long arg);
public static native long LDKCResult_boolPeerHandleErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NodeIdDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_NodeIdDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_NodeIdDecodeErrorZ_get_err(long arg);
+ public static native long LDKCResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(long arg);
+ public static native long LDKCResult_COption_NetworkUpdateZDecodeErrorZ_get_err(long arg);
public interface LDKAccess {
long get_utxo(byte[] genesis_hash, long short_channel_id);
}
}
static { LDKCOption_AccessZ.init(); }
public static native LDKCOption_AccessZ LDKCOption_AccessZ_ref_from_ptr(long ptr);
- public static native boolean LDKCResult_DirectionalChannelInfoDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelInfoDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_ChannelInfoDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_ChannelInfoDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_RoutingFeesDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_RoutingFeesDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_RoutingFeesDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NodeAnnouncementInfoDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_NodeAnnouncementInfoDecodeErrorZ_get_err(long arg);
- public static native long LDKCVec_u64Z_new(long[] elems);
- public static native boolean LDKCResult_NodeInfoDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_NodeInfoDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_NodeInfoDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NetworkGraphDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_NetworkGraphDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_NetworkGraphDecodeErrorZ_get_err(long arg);
public static class LDKCOption_CVec_NetAddressZZ {
}
static { LDKCOption_CVec_NetAddressZZ.init(); }
public static native LDKCOption_CVec_NetAddressZZ LDKCOption_CVec_NetAddressZZ_ref_from_ptr(long ptr);
- public static native boolean LDKCResult_NetAddressDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_NetAddressDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_NetAddressDecodeErrorZ_get_err(long arg);
- public static native long LDKCVec_UpdateAddHTLCZ_new(long[] elems);
- public static native long LDKCVec_UpdateFulfillHTLCZ_new(long[] elems);
- public static native long LDKCVec_UpdateFailHTLCZ_new(long[] elems);
- public static native long LDKCVec_UpdateFailMalformedHTLCZ_new(long[] elems);
- public static native boolean LDKCResult_AcceptChannelDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_AcceptChannelDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_AcceptChannelDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_AnnouncementSignaturesDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_AnnouncementSignaturesDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_AnnouncementSignaturesDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelReestablishDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_ChannelReestablishDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_ChannelReestablishDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ClosingSignedDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_ClosingSignedDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_ClosingSignedDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ClosingSignedFeeRangeDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_CommitmentSignedDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_CommitmentSignedDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_CommitmentSignedDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_FundingCreatedDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_FundingCreatedDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_FundingCreatedDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_FundingSignedDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_FundingSignedDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_FundingSignedDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_FundingLockedDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_FundingLockedDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_FundingLockedDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_InitDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_InitDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_InitDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_OpenChannelDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_OpenChannelDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_OpenChannelDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_RevokeAndACKDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_RevokeAndACKDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_RevokeAndACKDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ShutdownDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_ShutdownDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_ShutdownDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UpdateFailHTLCDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_UpdateFailHTLCDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_UpdateFailHTLCDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UpdateFeeDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_UpdateFeeDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_UpdateFeeDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UpdateFulfillHTLCDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_UpdateFulfillHTLCDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UpdateAddHTLCDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_UpdateAddHTLCDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_UpdateAddHTLCDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_PingDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_PingDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_PingDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_PongDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_PongDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_PongDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelAnnouncementDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_ChannelAnnouncementDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_ChannelAnnouncementDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UnsignedChannelUpdateDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_UnsignedChannelUpdateDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelUpdateDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_ChannelUpdateDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_ChannelUpdateDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ErrorMessageDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_ErrorMessageDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_ErrorMessageDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NodeAnnouncementDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_NodeAnnouncementDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_NodeAnnouncementDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_QueryShortChannelIdsDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_QueryShortChannelIdsDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_QueryShortChannelIdsDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_QueryChannelRangeDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_QueryChannelRangeDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_QueryChannelRangeDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ReplyChannelRangeDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_ReplyChannelRangeDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_ReplyChannelRangeDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_GossipTimestampFilterDecodeErrorZ_result_ok(long arg);
public static native long LDKCResult_GossipTimestampFilterDecodeErrorZ_get_ok(long arg);
public static native long LDKCResult_GossipTimestampFilterDecodeErrorZ_get_err(long arg);
public static class LDKSignOrCreationError {
}
static { LDKSignOrCreationError.init(); }
public static native LDKSignOrCreationError LDKSignOrCreationError_ref_from_ptr(long ptr);
- public static native boolean LDKCResult_InvoiceSignOrCreationErrorZ_result_ok(long arg);
public static native long LDKCResult_InvoiceSignOrCreationErrorZ_get_ok(long arg);
public static native long LDKCResult_InvoiceSignOrCreationErrorZ_get_err(long arg);
public interface LDKFilter {
}
static { LDKCOption_FilterZ.init(); }
public static native LDKCOption_FilterZ LDKCOption_FilterZ_ref_from_ptr(long ptr);
- public static native boolean LDKCResult_LockedChannelMonitorNoneZ_result_ok(long arg);
public static native long LDKCResult_LockedChannelMonitorNoneZ_get_ok(long arg);
public static native void LDKCResult_LockedChannelMonitorNoneZ_get_err(long arg);
- public static native long LDKCVec_OutPointZ_new(long[] elems);
public interface LDKMessageSendEventsProvider {
long[] get_and_clear_pending_msg_events();
}
public static native long TxOut_new(byte[] script_pubkey, long value);
// void TxOut_free(struct LDKTxOut _res);
public static native void TxOut_free(long _res);
+ // uint64_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
+ public static native long TxOut_clone_ptr(long arg);
// struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
public static native long TxOut_clone(long orig);
// void Str_free(struct LDKStr _res);
public static native long CResult_SecretKeyErrorZ_ok(byte[] o);
// struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_err(enum LDKSecp256k1Error e);
public static native long CResult_SecretKeyErrorZ_err(Secp256k1Error e);
+ // bool CResult_SecretKeyErrorZ_is_ok(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_SecretKeyErrorZ_is_ok(long o);
// void CResult_SecretKeyErrorZ_free(struct LDKCResult_SecretKeyErrorZ _res);
public static native void CResult_SecretKeyErrorZ_free(long _res);
// struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_ok(struct LDKPublicKey o);
public static native long CResult_PublicKeyErrorZ_ok(byte[] o);
// struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1Error e);
public static native long CResult_PublicKeyErrorZ_err(Secp256k1Error e);
+ // bool CResult_PublicKeyErrorZ_is_ok(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_PublicKeyErrorZ_is_ok(long o);
// void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
public static native void CResult_PublicKeyErrorZ_free(long _res);
+ // uint64_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg);
+ public static native long CResult_PublicKeyErrorZ_clone_ptr(long arg);
// struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_clone(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR orig);
public static native long CResult_PublicKeyErrorZ_clone(long orig);
// struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
public static native long CResult_TxCreationKeysDecodeErrorZ_ok(long o);
// struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_TxCreationKeysDecodeErrorZ_err(long e);
+ // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_TxCreationKeysDecodeErrorZ_is_ok(long o);
// void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
public static native void CResult_TxCreationKeysDecodeErrorZ_free(long _res);
+ // uint64_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_TxCreationKeysDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_TxCreationKeysDecodeErrorZ_clone(long orig);
// struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
public static native long CResult_ChannelPublicKeysDecodeErrorZ_ok(long o);
// struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_ChannelPublicKeysDecodeErrorZ_err(long e);
+ // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_ChannelPublicKeysDecodeErrorZ_is_ok(long o);
// void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
public static native void CResult_ChannelPublicKeysDecodeErrorZ_free(long _res);
+ // uint64_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_ChannelPublicKeysDecodeErrorZ_clone(long orig);
// struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_ok(struct LDKTxCreationKeys o);
public static native long CResult_TxCreationKeysErrorZ_ok(long o);
// struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_err(enum LDKSecp256k1Error e);
public static native long CResult_TxCreationKeysErrorZ_err(Secp256k1Error e);
+ // bool CResult_TxCreationKeysErrorZ_is_ok(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_TxCreationKeysErrorZ_is_ok(long o);
// void CResult_TxCreationKeysErrorZ_free(struct LDKCResult_TxCreationKeysErrorZ _res);
public static native void CResult_TxCreationKeysErrorZ_free(long _res);
+ // uint64_t CResult_TxCreationKeysErrorZ_clone_ptr(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR arg);
+ public static native long CResult_TxCreationKeysErrorZ_clone_ptr(long arg);
// struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_clone(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR orig);
public static native long CResult_TxCreationKeysErrorZ_clone(long orig);
// struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
public static native long COption_u32Z_none();
// void COption_u32Z_free(struct LDKCOption_u32Z _res);
public static native void COption_u32Z_free(long _res);
+ // uint64_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
+ public static native long COption_u32Z_clone_ptr(long arg);
// struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
public static native long COption_u32Z_clone(long orig);
// struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
public static native long CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(long o);
// struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_HTLCOutputInCommitmentDecodeErrorZ_err(long e);
+ // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(long o);
// void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
public static native void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(long _res);
+ // uint64_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(long orig);
// struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
public static native long CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(long o);
// struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(long e);
+ // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(long o);
// void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
public static native void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(long _res);
+ // uint64_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(long orig);
// struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
public static native long CResult_ChannelTransactionParametersDecodeErrorZ_ok(long o);
// struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_ChannelTransactionParametersDecodeErrorZ_err(long e);
+ // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(long o);
// void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
public static native void CResult_ChannelTransactionParametersDecodeErrorZ_free(long _res);
+ // uint64_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_ChannelTransactionParametersDecodeErrorZ_clone(long orig);
// void CVec_SignatureZ_free(struct LDKCVec_SignatureZ _res);
public static native long CResult_HolderCommitmentTransactionDecodeErrorZ_ok(long o);
// struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_HolderCommitmentTransactionDecodeErrorZ_err(long e);
+ // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(long o);
// void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
public static native void CResult_HolderCommitmentTransactionDecodeErrorZ_free(long _res);
+ // uint64_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_HolderCommitmentTransactionDecodeErrorZ_clone(long orig);
// struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
public static native long CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(long o);
// struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_BuiltCommitmentTransactionDecodeErrorZ_err(long e);
+ // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(long o);
// void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
public static native void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(long _res);
+ // uint64_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(long orig);
// struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
public static native long CResult_TrustedClosingTransactionNoneZ_ok(long o);
// struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
public static native long CResult_TrustedClosingTransactionNoneZ_err();
+ // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_TrustedClosingTransactionNoneZ_is_ok(long o);
// void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
public static native void CResult_TrustedClosingTransactionNoneZ_free(long _res);
// struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
public static native long CResult_CommitmentTransactionDecodeErrorZ_ok(long o);
// struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_CommitmentTransactionDecodeErrorZ_err(long e);
+ // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_CommitmentTransactionDecodeErrorZ_is_ok(long o);
// void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
public static native void CResult_CommitmentTransactionDecodeErrorZ_free(long _res);
+ // uint64_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_CommitmentTransactionDecodeErrorZ_clone(long orig);
// struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
public static native long CResult_TrustedCommitmentTransactionNoneZ_ok(long o);
// struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
public static native long CResult_TrustedCommitmentTransactionNoneZ_err();
+ // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_TrustedCommitmentTransactionNoneZ_is_ok(long o);
// void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
public static native void CResult_TrustedCommitmentTransactionNoneZ_free(long _res);
// struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_ok(struct LDKCVec_SignatureZ o);
public static native long CResult_CVec_SignatureZNoneZ_ok(byte[][] o);
// struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
public static native long CResult_CVec_SignatureZNoneZ_err();
+ // bool CResult_CVec_SignatureZNoneZ_is_ok(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_CVec_SignatureZNoneZ_is_ok(long o);
// void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
public static native void CResult_CVec_SignatureZNoneZ_free(long _res);
+ // uint64_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg);
+ public static native long CResult_CVec_SignatureZNoneZ_clone_ptr(long arg);
// struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
public static native long CResult_CVec_SignatureZNoneZ_clone(long orig);
// struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
public static native long CResult_ShutdownScriptDecodeErrorZ_ok(long o);
// struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_ShutdownScriptDecodeErrorZ_err(long e);
+ // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_ShutdownScriptDecodeErrorZ_is_ok(long o);
// void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
public static native void CResult_ShutdownScriptDecodeErrorZ_free(long _res);
+ // uint64_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_ShutdownScriptDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_ShutdownScriptDecodeErrorZ_clone(long orig);
// struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
public static native long CResult_ShutdownScriptInvalidShutdownScriptZ_ok(long o);
// struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
public static native long CResult_ShutdownScriptInvalidShutdownScriptZ_err(long e);
+ // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
+ public static native boolean CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(long o);
// void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
public static native void CResult_ShutdownScriptInvalidShutdownScriptZ_free(long _res);
+ // uint64_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
+ public static native long CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(long arg);
// struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
public static native long CResult_ShutdownScriptInvalidShutdownScriptZ_clone(long orig);
// struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_ok(void);
public static native long CResult_NoneErrorZ_ok();
// struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_err(enum LDKIOError e);
public static native long CResult_NoneErrorZ_err(IOError e);
+ // bool CResult_NoneErrorZ_is_ok(const struct LDKCResult_NoneErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_NoneErrorZ_is_ok(long o);
// void CResult_NoneErrorZ_free(struct LDKCResult_NoneErrorZ _res);
public static native void CResult_NoneErrorZ_free(long _res);
+ // uint64_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg);
+ public static native long CResult_NoneErrorZ_clone_ptr(long arg);
// struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_clone(const struct LDKCResult_NoneErrorZ *NONNULL_PTR orig);
public static native long CResult_NoneErrorZ_clone(long orig);
// struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
public static native long CResult_RouteHopDecodeErrorZ_ok(long o);
// struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_RouteHopDecodeErrorZ_err(long e);
+ // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_RouteHopDecodeErrorZ_is_ok(long o);
// void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
public static native void CResult_RouteHopDecodeErrorZ_free(long _res);
+ // uint64_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_RouteHopDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_RouteHopDecodeErrorZ_clone(long orig);
// void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
public static native long CResult_RouteDecodeErrorZ_ok(long o);
// struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_RouteDecodeErrorZ_err(long e);
+ // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_RouteDecodeErrorZ_is_ok(long o);
// void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
public static native void CResult_RouteDecodeErrorZ_free(long _res);
+ // uint64_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_RouteDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_RouteDecodeErrorZ_clone(long orig);
// struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
public static native long CResult_RouteParametersDecodeErrorZ_ok(long o);
// struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_RouteParametersDecodeErrorZ_err(long e);
+ // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_RouteParametersDecodeErrorZ_is_ok(long o);
// void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
public static native void CResult_RouteParametersDecodeErrorZ_free(long _res);
+ // uint64_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_RouteParametersDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_RouteParametersDecodeErrorZ_clone(long orig);
// void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
public static native long COption_u64Z_none();
// void COption_u64Z_free(struct LDKCOption_u64Z _res);
public static native void COption_u64Z_free(long _res);
+ // uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
+ public static native long COption_u64Z_clone_ptr(long arg);
// struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
public static native long COption_u64Z_clone(long orig);
// struct LDKCResult_PayeeDecodeErrorZ CResult_PayeeDecodeErrorZ_ok(struct LDKPayee o);
public static native long CResult_PayeeDecodeErrorZ_ok(long o);
// struct LDKCResult_PayeeDecodeErrorZ CResult_PayeeDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_PayeeDecodeErrorZ_err(long e);
+ // bool CResult_PayeeDecodeErrorZ_is_ok(const struct LDKCResult_PayeeDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_PayeeDecodeErrorZ_is_ok(long o);
// void CResult_PayeeDecodeErrorZ_free(struct LDKCResult_PayeeDecodeErrorZ _res);
public static native void CResult_PayeeDecodeErrorZ_free(long _res);
+ // uint64_t CResult_PayeeDecodeErrorZ_clone_ptr(LDKCResult_PayeeDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_PayeeDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_PayeeDecodeErrorZ CResult_PayeeDecodeErrorZ_clone(const struct LDKCResult_PayeeDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_PayeeDecodeErrorZ_clone(long orig);
// void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
public static native long CResult_RouteHintDecodeErrorZ_ok(long o);
// struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_RouteHintDecodeErrorZ_err(long e);
+ // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_RouteHintDecodeErrorZ_is_ok(long o);
// void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
public static native void CResult_RouteHintDecodeErrorZ_free(long _res);
+ // uint64_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_RouteHintDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_RouteHintDecodeErrorZ_clone(long orig);
// struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
public static native long CResult_RouteHintHopDecodeErrorZ_ok(long o);
// struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_RouteHintHopDecodeErrorZ_err(long e);
+ // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_RouteHintHopDecodeErrorZ_is_ok(long o);
// void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
public static native void CResult_RouteHintHopDecodeErrorZ_free(long _res);
+ // uint64_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_RouteHintHopDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_RouteHintHopDecodeErrorZ_clone(long orig);
// void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
public static native long CResult_RouteLightningErrorZ_ok(long o);
// struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
public static native long CResult_RouteLightningErrorZ_err(long e);
+ // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_RouteLightningErrorZ_is_ok(long o);
// void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
public static native void CResult_RouteLightningErrorZ_free(long _res);
+ // uint64_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
+ public static native long CResult_RouteLightningErrorZ_clone_ptr(long arg);
// struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
public static native long CResult_RouteLightningErrorZ_clone(long orig);
// struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_ok(struct LDKTxOut o);
public static native long CResult_TxOutAccessErrorZ_ok(long o);
// struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_err(enum LDKAccessError e);
public static native long CResult_TxOutAccessErrorZ_err(AccessError e);
+ // bool CResult_TxOutAccessErrorZ_is_ok(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_TxOutAccessErrorZ_is_ok(long o);
// void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
public static native void CResult_TxOutAccessErrorZ_free(long _res);
+ // uint64_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg);
+ public static native long CResult_TxOutAccessErrorZ_clone_ptr(long arg);
// struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
public static native long CResult_TxOutAccessErrorZ_clone(long orig);
+ // uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
+ public static native long C2Tuple_usizeTransactionZ_clone_ptr(long arg);
// struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
public static native long C2Tuple_usizeTransactionZ_clone(long orig);
// struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
public static native long CResult_NoneChannelMonitorUpdateErrZ_ok();
// struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_err(enum LDKChannelMonitorUpdateErr e);
public static native long CResult_NoneChannelMonitorUpdateErrZ_err(ChannelMonitorUpdateErr e);
+ // bool CResult_NoneChannelMonitorUpdateErrZ_is_ok(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR o);
+ public static native boolean CResult_NoneChannelMonitorUpdateErrZ_is_ok(long o);
// void CResult_NoneChannelMonitorUpdateErrZ_free(struct LDKCResult_NoneChannelMonitorUpdateErrZ _res);
public static native void CResult_NoneChannelMonitorUpdateErrZ_free(long _res);
+ // uint64_t CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR arg);
+ public static native long CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(long arg);
// struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_clone(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR orig);
public static native long CResult_NoneChannelMonitorUpdateErrZ_clone(long orig);
// void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
public static native long COption_C2Tuple_usizeTransactionZZ_none();
// void COption_C2Tuple_usizeTransactionZZ_free(struct LDKCOption_C2Tuple_usizeTransactionZZ _res);
public static native void COption_C2Tuple_usizeTransactionZZ_free(long _res);
+ // uint64_t COption_C2Tuple_usizeTransactionZZ_clone_ptr(LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR arg);
+ public static native long COption_C2Tuple_usizeTransactionZZ_clone_ptr(long arg);
// struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_clone(const struct LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR orig);
public static native long COption_C2Tuple_usizeTransactionZZ_clone(long orig);
+ // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
+ public static native long COption_ClosureReasonZ_some(long o);
+ // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
+ public static native long COption_ClosureReasonZ_none();
+ // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
+ public static native void COption_ClosureReasonZ_free(long _res);
+ // uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
+ public static native long COption_ClosureReasonZ_clone_ptr(long arg);
+ // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
+ public static native long COption_ClosureReasonZ_clone(long orig);
+ // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
+ public static native long CResult_COption_ClosureReasonZDecodeErrorZ_ok(long o);
+ // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
+ public static native long CResult_COption_ClosureReasonZDecodeErrorZ_err(long e);
+ // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(long o);
+ // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
+ public static native void CResult_COption_ClosureReasonZDecodeErrorZ_free(long _res);
+ // uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(long arg);
+ // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
+ public static native long CResult_COption_ClosureReasonZDecodeErrorZ_clone(long orig);
// struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
public static native long COption_NetworkUpdateZ_some(long o);
// struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
public static native long COption_NetworkUpdateZ_none();
// void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
public static native void COption_NetworkUpdateZ_free(long _res);
+ // uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
+ public static native long COption_NetworkUpdateZ_clone_ptr(long arg);
// struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
public static native long COption_NetworkUpdateZ_clone(long orig);
// void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
public static native void CVec_SpendableOutputDescriptorZ_free(long[] _res);
+ // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
+ public static native long COption_EventZ_some(long o);
+ // struct LDKCOption_EventZ COption_EventZ_none(void);
+ public static native long COption_EventZ_none();
+ // void COption_EventZ_free(struct LDKCOption_EventZ _res);
+ public static native void COption_EventZ_free(long _res);
+ // uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
+ public static native long COption_EventZ_clone_ptr(long arg);
+ // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
+ public static native long COption_EventZ_clone(long orig);
+ // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
+ public static native long CResult_COption_EventZDecodeErrorZ_ok(long o);
+ // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
+ public static native long CResult_COption_EventZDecodeErrorZ_err(long e);
+ // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_COption_EventZDecodeErrorZ_is_ok(long o);
+ // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
+ public static native void CResult_COption_EventZDecodeErrorZ_free(long _res);
+ // uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_COption_EventZDecodeErrorZ_clone_ptr(long arg);
+ // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
+ public static native long CResult_COption_EventZDecodeErrorZ_clone(long orig);
// void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
public static native void CVec_MessageSendEventZ_free(long[] _res);
// struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
public static native long CResult_InitFeaturesDecodeErrorZ_ok(long o);
// struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_InitFeaturesDecodeErrorZ_err(long e);
+ // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_InitFeaturesDecodeErrorZ_is_ok(long o);
// void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
public static native void CResult_InitFeaturesDecodeErrorZ_free(long _res);
// struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
public static native long CResult_NodeFeaturesDecodeErrorZ_ok(long o);
// struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_NodeFeaturesDecodeErrorZ_err(long e);
+ // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_NodeFeaturesDecodeErrorZ_is_ok(long o);
// void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
public static native void CResult_NodeFeaturesDecodeErrorZ_free(long _res);
// struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
public static native long CResult_ChannelFeaturesDecodeErrorZ_ok(long o);
// struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_ChannelFeaturesDecodeErrorZ_err(long e);
+ // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_ChannelFeaturesDecodeErrorZ_is_ok(long o);
// void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
public static native void CResult_ChannelFeaturesDecodeErrorZ_free(long _res);
// struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
public static native long CResult_InvoiceFeaturesDecodeErrorZ_ok(long o);
// struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_InvoiceFeaturesDecodeErrorZ_err(long e);
+ // bool CResult_InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_InvoiceFeaturesDecodeErrorZ_is_ok(long o);
// void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
public static native void CResult_InvoiceFeaturesDecodeErrorZ_free(long _res);
// struct LDKCResult_ScoringParametersDecodeErrorZ CResult_ScoringParametersDecodeErrorZ_ok(struct LDKScoringParameters o);
public static native long CResult_ScoringParametersDecodeErrorZ_ok(long o);
// struct LDKCResult_ScoringParametersDecodeErrorZ CResult_ScoringParametersDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_ScoringParametersDecodeErrorZ_err(long e);
+ // bool CResult_ScoringParametersDecodeErrorZ_is_ok(const struct LDKCResult_ScoringParametersDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_ScoringParametersDecodeErrorZ_is_ok(long o);
// void CResult_ScoringParametersDecodeErrorZ_free(struct LDKCResult_ScoringParametersDecodeErrorZ _res);
public static native void CResult_ScoringParametersDecodeErrorZ_free(long _res);
// struct LDKCResult_ScorerDecodeErrorZ CResult_ScorerDecodeErrorZ_ok(struct LDKScorer o);
public static native long CResult_ScorerDecodeErrorZ_ok(long o);
// struct LDKCResult_ScorerDecodeErrorZ CResult_ScorerDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_ScorerDecodeErrorZ_err(long e);
+ // bool CResult_ScorerDecodeErrorZ_is_ok(const struct LDKCResult_ScorerDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_ScorerDecodeErrorZ_is_ok(long o);
// void CResult_ScorerDecodeErrorZ_free(struct LDKCResult_ScorerDecodeErrorZ _res);
public static native void CResult_ScorerDecodeErrorZ_free(long _res);
// struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
public static native long CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(long o);
// struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(long e);
+ // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(long o);
// void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
public static native void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(long _res);
+ // uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(long orig);
// struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
public static native long CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(long o);
// struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(long e);
+ // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(long o);
// void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
public static native void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(long _res);
+ // uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(long orig);
// struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
public static native long CResult_SpendableOutputDescriptorDecodeErrorZ_ok(long o);
// struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_SpendableOutputDescriptorDecodeErrorZ_err(long e);
+ // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(long o);
// void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
public static native void CResult_SpendableOutputDescriptorDecodeErrorZ_free(long _res);
+ // uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_SpendableOutputDescriptorDecodeErrorZ_clone(long orig);
// struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
public static native long CResult_NoneNoneZ_ok();
// struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
public static native long CResult_NoneNoneZ_err();
+ // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_NoneNoneZ_is_ok(long o);
// void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
public static native void CResult_NoneNoneZ_free(long _res);
+ // uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
+ public static native long CResult_NoneNoneZ_clone_ptr(long arg);
// struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
public static native long CResult_NoneNoneZ_clone(long orig);
+ // uint64_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg);
+ public static native long C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(long arg);
// struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
public static native long C2Tuple_SignatureCVec_SignatureZZ_clone(long orig);
// struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
public static native long CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(long o);
// struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
public static native long CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
+ // bool CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(long o);
// void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
public static native void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(long _res);
+ // uint64_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg);
+ public static native long CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(long arg);
// struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
public static native long CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(long orig);
// struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
public static native long CResult_SignatureNoneZ_ok(byte[] o);
// struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
public static native long CResult_SignatureNoneZ_err();
+ // bool CResult_SignatureNoneZ_is_ok(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_SignatureNoneZ_is_ok(long o);
// void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
public static native void CResult_SignatureNoneZ_free(long _res);
+ // uint64_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg);
+ public static native long CResult_SignatureNoneZ_clone_ptr(long arg);
// struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
public static native long CResult_SignatureNoneZ_clone(long orig);
// struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
public static native long CResult_SignDecodeErrorZ_ok(long o);
// struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_SignDecodeErrorZ_err(long e);
+ // bool CResult_SignDecodeErrorZ_is_ok(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_SignDecodeErrorZ_is_ok(long o);
// void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
public static native void CResult_SignDecodeErrorZ_free(long _res);
+ // uint64_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_SignDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_SignDecodeErrorZ_clone(long orig);
// void CVec_u8Z_free(struct LDKCVec_u8Z _res);
public static native long CResult_RecoverableSignatureNoneZ_ok(byte[] arg);
// struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
public static native long CResult_RecoverableSignatureNoneZ_err();
+ // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_RecoverableSignatureNoneZ_is_ok(long o);
// void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
public static native void CResult_RecoverableSignatureNoneZ_free(long _res);
+ // uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
+ public static native long CResult_RecoverableSignatureNoneZ_clone_ptr(long arg);
// struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
public static native long CResult_RecoverableSignatureNoneZ_clone(long orig);
// void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
public static native long CResult_CVec_CVec_u8ZZNoneZ_ok(byte[][] o);
// struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
public static native long CResult_CVec_CVec_u8ZZNoneZ_err();
+ // bool CResult_CVec_CVec_u8ZZNoneZ_is_ok(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_CVec_CVec_u8ZZNoneZ_is_ok(long o);
// void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
public static native void CResult_CVec_CVec_u8ZZNoneZ_free(long _res);
+ // uint64_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg);
+ public static native long CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(long arg);
// struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
public static native long CResult_CVec_CVec_u8ZZNoneZ_clone(long orig);
// struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
public static native long CResult_InMemorySignerDecodeErrorZ_ok(long o);
// struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_InMemorySignerDecodeErrorZ_err(long e);
+ // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_InMemorySignerDecodeErrorZ_is_ok(long o);
// void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
public static native void CResult_InMemorySignerDecodeErrorZ_free(long _res);
+ // uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_InMemorySignerDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_InMemorySignerDecodeErrorZ_clone(long orig);
// void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
public static native long CResult_TransactionNoneZ_ok(byte[] o);
// struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
public static native long CResult_TransactionNoneZ_err();
+ // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_TransactionNoneZ_is_ok(long o);
// void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
public static native void CResult_TransactionNoneZ_free(long _res);
+ // uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
+ public static native long CResult_TransactionNoneZ_clone_ptr(long arg);
// struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
public static native long CResult_TransactionNoneZ_clone(long orig);
+ // uint64_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg);
+ public static native long C2Tuple_BlockHashChannelMonitorZ_clone_ptr(long arg);
// struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_clone(const struct LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR orig);
public static native long C2Tuple_BlockHashChannelMonitorZ_clone(long orig);
// struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
public static native long CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_ok(long[] o);
// struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_err(enum LDKIOError e);
public static native long CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_err(IOError e);
+ // bool CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_is_ok(const struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_is_ok(long o);
// void CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ _res);
public static native void CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(long _res);
+ // uint64_t CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone_ptr(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ *NONNULL_PTR arg);
+ public static native long CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone_ptr(long arg);
// struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone(const struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ *NONNULL_PTR orig);
public static native long CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone(long orig);
// struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
public static native long COption_u16Z_none();
// void COption_u16Z_free(struct LDKCOption_u16Z _res);
public static native void COption_u16Z_free(long _res);
+ // uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
+ public static native long COption_u16Z_clone_ptr(long arg);
// struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
public static native long COption_u16Z_clone(long orig);
// struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
public static native long CResult_NoneAPIErrorZ_ok();
// struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
public static native long CResult_NoneAPIErrorZ_err(long e);
+ // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_NoneAPIErrorZ_is_ok(long o);
// void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
public static native void CResult_NoneAPIErrorZ_free(long _res);
+ // uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
+ public static native long CResult_NoneAPIErrorZ_clone_ptr(long arg);
// struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
public static native long CResult_NoneAPIErrorZ_clone(long orig);
// void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
public static native long CResult__u832APIErrorZ_ok(byte[] o);
// struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_err(struct LDKAPIError e);
public static native long CResult__u832APIErrorZ_err(long e);
+ // bool CResult__u832APIErrorZ_is_ok(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR o);
+ public static native boolean CResult__u832APIErrorZ_is_ok(long o);
// void CResult__u832APIErrorZ_free(struct LDKCResult__u832APIErrorZ _res);
public static native void CResult__u832APIErrorZ_free(long _res);
+ // uint64_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg);
+ public static native long CResult__u832APIErrorZ_clone_ptr(long arg);
// struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_clone(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR orig);
public static native long CResult__u832APIErrorZ_clone(long orig);
// struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
public static native long CResult_PaymentIdPaymentSendFailureZ_ok(byte[] o);
// struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
public static native long CResult_PaymentIdPaymentSendFailureZ_err(long e);
+ // bool CResult_PaymentIdPaymentSendFailureZ_is_ok(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR o);
+ public static native boolean CResult_PaymentIdPaymentSendFailureZ_is_ok(long o);
// void CResult_PaymentIdPaymentSendFailureZ_free(struct LDKCResult_PaymentIdPaymentSendFailureZ _res);
public static native void CResult_PaymentIdPaymentSendFailureZ_free(long _res);
+ // uint64_t CResult_PaymentIdPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR arg);
+ public static native long CResult_PaymentIdPaymentSendFailureZ_clone_ptr(long arg);
// struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_clone(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR orig);
public static native long CResult_PaymentIdPaymentSendFailureZ_clone(long orig);
// struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
public static native long CResult_NonePaymentSendFailureZ_ok();
// struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
public static native long CResult_NonePaymentSendFailureZ_err(long e);
+ // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
+ public static native boolean CResult_NonePaymentSendFailureZ_is_ok(long o);
// void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
public static native void CResult_NonePaymentSendFailureZ_free(long _res);
+ // uint64_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
+ public static native long CResult_NonePaymentSendFailureZ_clone_ptr(long arg);
// struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
public static native long CResult_NonePaymentSendFailureZ_clone(long orig);
+ // uint64_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg);
+ public static native long C2Tuple_PaymentHashPaymentIdZ_clone_ptr(long arg);
// struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_clone(const struct LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR orig);
public static native long C2Tuple_PaymentHashPaymentIdZ_clone(long orig);
// struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
public static native long CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(long o);
// struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
public static native long CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(long e);
+ // bool CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR o);
+ public static native boolean CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(long o);
// void CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res);
public static native void CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(long _res);
+ // uint64_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg);
+ public static native long CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(long arg);
// struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR orig);
public static native long CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(long orig);
// void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
public static native void CVec_NetAddressZ_free(long[] _res);
+ // uint64_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg);
+ public static native long C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(long arg);
// struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_clone(const struct LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR orig);
public static native long C2Tuple_PaymentHashPaymentSecretZ_clone(long orig);
// struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
public static native long CResult_PaymentSecretAPIErrorZ_ok(byte[] o);
// struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_err(struct LDKAPIError e);
public static native long CResult_PaymentSecretAPIErrorZ_err(long e);
+ // bool CResult_PaymentSecretAPIErrorZ_is_ok(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_PaymentSecretAPIErrorZ_is_ok(long o);
// void CResult_PaymentSecretAPIErrorZ_free(struct LDKCResult_PaymentSecretAPIErrorZ _res);
public static native void CResult_PaymentSecretAPIErrorZ_free(long _res);
+ // uint64_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg);
+ public static native long CResult_PaymentSecretAPIErrorZ_clone_ptr(long arg);
// struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_clone(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR orig);
public static native long CResult_PaymentSecretAPIErrorZ_clone(long orig);
// void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
public static native long CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(long o);
// struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(long e);
+ // bool CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(long o);
// void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
public static native void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(long _res);
// struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
public static native long CResult_ChannelConfigDecodeErrorZ_ok(long o);
// struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_ChannelConfigDecodeErrorZ_err(long e);
+ // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_ChannelConfigDecodeErrorZ_is_ok(long o);
// void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
public static native void CResult_ChannelConfigDecodeErrorZ_free(long _res);
+ // uint64_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_ChannelConfigDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_ChannelConfigDecodeErrorZ_clone(long orig);
// struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
public static native long CResult_OutPointDecodeErrorZ_ok(long o);
// struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_OutPointDecodeErrorZ_err(long e);
+ // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_OutPointDecodeErrorZ_is_ok(long o);
// void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
public static native void CResult_OutPointDecodeErrorZ_free(long _res);
+ // uint64_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_OutPointDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_OutPointDecodeErrorZ_clone(long orig);
// struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
public static native long COption_TypeZ_none();
// void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
public static native void COption_TypeZ_free(long _res);
+ // uint64_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
+ public static native long COption_TypeZ_clone_ptr(long arg);
// struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
public static native long COption_TypeZ_clone(long orig);
// struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
public static native long CResult_COption_TypeZDecodeErrorZ_ok(long o);
// struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_COption_TypeZDecodeErrorZ_err(long e);
+ // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_COption_TypeZDecodeErrorZ_is_ok(long o);
// void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
public static native void CResult_COption_TypeZDecodeErrorZ_free(long _res);
+ // uint64_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_COption_TypeZDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_COption_TypeZDecodeErrorZ_clone(long orig);
// struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_ok(struct LDKThirtyTwoBytes o);
public static native long CResult_PaymentIdPaymentErrorZ_ok(byte[] o);
// struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_err(struct LDKPaymentError e);
public static native long CResult_PaymentIdPaymentErrorZ_err(long e);
+ // bool CResult_PaymentIdPaymentErrorZ_is_ok(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_PaymentIdPaymentErrorZ_is_ok(long o);
// void CResult_PaymentIdPaymentErrorZ_free(struct LDKCResult_PaymentIdPaymentErrorZ _res);
public static native void CResult_PaymentIdPaymentErrorZ_free(long _res);
+ // uint64_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg);
+ public static native long CResult_PaymentIdPaymentErrorZ_clone_ptr(long arg);
// struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_clone(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR orig);
public static native long CResult_PaymentIdPaymentErrorZ_clone(long orig);
// struct LDKCResult_SiPrefixNoneZ CResult_SiPrefixNoneZ_ok(enum LDKSiPrefix o);
public static native long CResult_SiPrefixNoneZ_ok(SiPrefix o);
// struct LDKCResult_SiPrefixNoneZ CResult_SiPrefixNoneZ_err(void);
public static native long CResult_SiPrefixNoneZ_err();
+ // bool CResult_SiPrefixNoneZ_is_ok(const struct LDKCResult_SiPrefixNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_SiPrefixNoneZ_is_ok(long o);
// void CResult_SiPrefixNoneZ_free(struct LDKCResult_SiPrefixNoneZ _res);
public static native void CResult_SiPrefixNoneZ_free(long _res);
+ // uint64_t CResult_SiPrefixNoneZ_clone_ptr(LDKCResult_SiPrefixNoneZ *NONNULL_PTR arg);
+ public static native long CResult_SiPrefixNoneZ_clone_ptr(long arg);
// struct LDKCResult_SiPrefixNoneZ CResult_SiPrefixNoneZ_clone(const struct LDKCResult_SiPrefixNoneZ *NONNULL_PTR orig);
public static native long CResult_SiPrefixNoneZ_clone(long orig);
// struct LDKCResult_InvoiceNoneZ CResult_InvoiceNoneZ_ok(struct LDKInvoice o);
public static native long CResult_InvoiceNoneZ_ok(long o);
// struct LDKCResult_InvoiceNoneZ CResult_InvoiceNoneZ_err(void);
public static native long CResult_InvoiceNoneZ_err();
+ // bool CResult_InvoiceNoneZ_is_ok(const struct LDKCResult_InvoiceNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_InvoiceNoneZ_is_ok(long o);
// void CResult_InvoiceNoneZ_free(struct LDKCResult_InvoiceNoneZ _res);
public static native void CResult_InvoiceNoneZ_free(long _res);
+ // uint64_t CResult_InvoiceNoneZ_clone_ptr(LDKCResult_InvoiceNoneZ *NONNULL_PTR arg);
+ public static native long CResult_InvoiceNoneZ_clone_ptr(long arg);
// struct LDKCResult_InvoiceNoneZ CResult_InvoiceNoneZ_clone(const struct LDKCResult_InvoiceNoneZ *NONNULL_PTR orig);
public static native long CResult_InvoiceNoneZ_clone(long orig);
// struct LDKCResult_SignedRawInvoiceNoneZ CResult_SignedRawInvoiceNoneZ_ok(struct LDKSignedRawInvoice o);
public static native long CResult_SignedRawInvoiceNoneZ_ok(long o);
// struct LDKCResult_SignedRawInvoiceNoneZ CResult_SignedRawInvoiceNoneZ_err(void);
public static native long CResult_SignedRawInvoiceNoneZ_err();
+ // bool CResult_SignedRawInvoiceNoneZ_is_ok(const struct LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_SignedRawInvoiceNoneZ_is_ok(long o);
// void CResult_SignedRawInvoiceNoneZ_free(struct LDKCResult_SignedRawInvoiceNoneZ _res);
public static native void CResult_SignedRawInvoiceNoneZ_free(long _res);
+ // uint64_t CResult_SignedRawInvoiceNoneZ_clone_ptr(LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR arg);
+ public static native long CResult_SignedRawInvoiceNoneZ_clone_ptr(long arg);
// struct LDKCResult_SignedRawInvoiceNoneZ CResult_SignedRawInvoiceNoneZ_clone(const struct LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR orig);
public static native long CResult_SignedRawInvoiceNoneZ_clone(long orig);
+ // uint64_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg);
+ public static native long C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(long arg);
// struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR orig);
public static native long C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(long orig);
// struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(struct LDKRawInvoice a, struct LDKThirtyTwoBytes b, struct LDKInvoiceSignature c);
public static native long CResult_PayeePubKeyErrorZ_ok(long o);
// struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_err(enum LDKSecp256k1Error e);
public static native long CResult_PayeePubKeyErrorZ_err(Secp256k1Error e);
+ // bool CResult_PayeePubKeyErrorZ_is_ok(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_PayeePubKeyErrorZ_is_ok(long o);
// void CResult_PayeePubKeyErrorZ_free(struct LDKCResult_PayeePubKeyErrorZ _res);
public static native void CResult_PayeePubKeyErrorZ_free(long _res);
+ // uint64_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg);
+ public static native long CResult_PayeePubKeyErrorZ_clone_ptr(long arg);
// struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_clone(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR orig);
public static native long CResult_PayeePubKeyErrorZ_clone(long orig);
// void CVec_PrivateRouteZ_free(struct LDKCVec_PrivateRouteZ _res);
public static native long CResult_PositiveTimestampCreationErrorZ_ok(long o);
// struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
public static native long CResult_PositiveTimestampCreationErrorZ_err(CreationError e);
+ // bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_PositiveTimestampCreationErrorZ_is_ok(long o);
// void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
public static native void CResult_PositiveTimestampCreationErrorZ_free(long _res);
+ // uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
+ public static native long CResult_PositiveTimestampCreationErrorZ_clone_ptr(long arg);
// struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
public static native long CResult_PositiveTimestampCreationErrorZ_clone(long orig);
// struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_ok(void);
public static native long CResult_NoneSemanticErrorZ_ok();
// struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_err(enum LDKSemanticError e);
public static native long CResult_NoneSemanticErrorZ_err(SemanticError e);
+ // bool CResult_NoneSemanticErrorZ_is_ok(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_NoneSemanticErrorZ_is_ok(long o);
// void CResult_NoneSemanticErrorZ_free(struct LDKCResult_NoneSemanticErrorZ _res);
public static native void CResult_NoneSemanticErrorZ_free(long _res);
+ // uint64_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg);
+ public static native long CResult_NoneSemanticErrorZ_clone_ptr(long arg);
// struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_clone(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR orig);
public static native long CResult_NoneSemanticErrorZ_clone(long orig);
// struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_ok(struct LDKInvoice o);
public static native long CResult_InvoiceSemanticErrorZ_ok(long o);
// struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_err(enum LDKSemanticError e);
public static native long CResult_InvoiceSemanticErrorZ_err(SemanticError e);
+ // bool CResult_InvoiceSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_InvoiceSemanticErrorZ_is_ok(long o);
// void CResult_InvoiceSemanticErrorZ_free(struct LDKCResult_InvoiceSemanticErrorZ _res);
public static native void CResult_InvoiceSemanticErrorZ_free(long _res);
+ // uint64_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg);
+ public static native long CResult_InvoiceSemanticErrorZ_clone_ptr(long arg);
// struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_clone(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR orig);
public static native long CResult_InvoiceSemanticErrorZ_clone(long orig);
// struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
public static native long CResult_DescriptionCreationErrorZ_ok(long o);
// struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
public static native long CResult_DescriptionCreationErrorZ_err(CreationError e);
+ // bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_DescriptionCreationErrorZ_is_ok(long o);
// void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
public static native void CResult_DescriptionCreationErrorZ_free(long _res);
+ // uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
+ public static native long CResult_DescriptionCreationErrorZ_clone_ptr(long arg);
// struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
public static native long CResult_DescriptionCreationErrorZ_clone(long orig);
// struct LDKCResult_ExpiryTimeCreationErrorZ CResult_ExpiryTimeCreationErrorZ_ok(struct LDKExpiryTime o);
public static native long CResult_ExpiryTimeCreationErrorZ_ok(long o);
// struct LDKCResult_ExpiryTimeCreationErrorZ CResult_ExpiryTimeCreationErrorZ_err(enum LDKCreationError e);
public static native long CResult_ExpiryTimeCreationErrorZ_err(CreationError e);
+ // bool CResult_ExpiryTimeCreationErrorZ_is_ok(const struct LDKCResult_ExpiryTimeCreationErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_ExpiryTimeCreationErrorZ_is_ok(long o);
// void CResult_ExpiryTimeCreationErrorZ_free(struct LDKCResult_ExpiryTimeCreationErrorZ _res);
public static native void CResult_ExpiryTimeCreationErrorZ_free(long _res);
+ // uint64_t CResult_ExpiryTimeCreationErrorZ_clone_ptr(LDKCResult_ExpiryTimeCreationErrorZ *NONNULL_PTR arg);
+ public static native long CResult_ExpiryTimeCreationErrorZ_clone_ptr(long arg);
// struct LDKCResult_ExpiryTimeCreationErrorZ CResult_ExpiryTimeCreationErrorZ_clone(const struct LDKCResult_ExpiryTimeCreationErrorZ *NONNULL_PTR orig);
public static native long CResult_ExpiryTimeCreationErrorZ_clone(long orig);
// struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
public static native long CResult_PrivateRouteCreationErrorZ_ok(long o);
// struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
public static native long CResult_PrivateRouteCreationErrorZ_err(CreationError e);
+ // bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_PrivateRouteCreationErrorZ_is_ok(long o);
// void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
public static native void CResult_PrivateRouteCreationErrorZ_free(long _res);
+ // uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
+ public static native long CResult_PrivateRouteCreationErrorZ_clone_ptr(long arg);
// struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
public static native long CResult_PrivateRouteCreationErrorZ_clone(long orig);
// struct LDKCResult_StringErrorZ CResult_StringErrorZ_ok(struct LDKStr o);
public static native long CResult_StringErrorZ_ok(String o);
// struct LDKCResult_StringErrorZ CResult_StringErrorZ_err(enum LDKSecp256k1Error e);
public static native long CResult_StringErrorZ_err(Secp256k1Error e);
+ // bool CResult_StringErrorZ_is_ok(const struct LDKCResult_StringErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_StringErrorZ_is_ok(long o);
// void CResult_StringErrorZ_free(struct LDKCResult_StringErrorZ _res);
public static native void CResult_StringErrorZ_free(long _res);
// struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
public static native long CResult_ChannelMonitorUpdateDecodeErrorZ_ok(long o);
// struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_ChannelMonitorUpdateDecodeErrorZ_err(long e);
+ // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(long o);
// void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
public static native void CResult_ChannelMonitorUpdateDecodeErrorZ_free(long _res);
+ // uint64_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_ChannelMonitorUpdateDecodeErrorZ_clone(long orig);
+ // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
+ public static native long COption_MonitorEventZ_some(long o);
+ // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
+ public static native long COption_MonitorEventZ_none();
+ // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
+ public static native void COption_MonitorEventZ_free(long _res);
+ // uint64_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
+ public static native long COption_MonitorEventZ_clone_ptr(long arg);
+ // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
+ public static native long COption_MonitorEventZ_clone(long orig);
+ // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
+ public static native long CResult_COption_MonitorEventZDecodeErrorZ_ok(long o);
+ // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
+ public static native long CResult_COption_MonitorEventZDecodeErrorZ_err(long e);
+ // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_COption_MonitorEventZDecodeErrorZ_is_ok(long o);
+ // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
+ public static native void CResult_COption_MonitorEventZDecodeErrorZ_free(long _res);
+ // uint64_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(long arg);
+ // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
+ public static native long CResult_COption_MonitorEventZDecodeErrorZ_clone(long orig);
// struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
public static native long CResult_HTLCUpdateDecodeErrorZ_ok(long o);
// struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_HTLCUpdateDecodeErrorZ_err(long e);
+ // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_HTLCUpdateDecodeErrorZ_is_ok(long o);
// void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
public static native void CResult_HTLCUpdateDecodeErrorZ_free(long _res);
+ // uint64_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_HTLCUpdateDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_HTLCUpdateDecodeErrorZ_clone(long orig);
// struct LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_ok(void);
public static native long CResult_NoneMonitorUpdateErrorZ_ok();
// struct LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_err(struct LDKMonitorUpdateError e);
public static native long CResult_NoneMonitorUpdateErrorZ_err(long e);
+ // bool CResult_NoneMonitorUpdateErrorZ_is_ok(const struct LDKCResult_NoneMonitorUpdateErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_NoneMonitorUpdateErrorZ_is_ok(long o);
// void CResult_NoneMonitorUpdateErrorZ_free(struct LDKCResult_NoneMonitorUpdateErrorZ _res);
public static native void CResult_NoneMonitorUpdateErrorZ_free(long _res);
+ // uint64_t CResult_NoneMonitorUpdateErrorZ_clone_ptr(LDKCResult_NoneMonitorUpdateErrorZ *NONNULL_PTR arg);
+ public static native long CResult_NoneMonitorUpdateErrorZ_clone_ptr(long arg);
// struct LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_clone(const struct LDKCResult_NoneMonitorUpdateErrorZ *NONNULL_PTR orig);
public static native long CResult_NoneMonitorUpdateErrorZ_clone(long orig);
+ // uint64_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg);
+ public static native long C2Tuple_OutPointScriptZ_clone_ptr(long arg);
// struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_clone(const struct LDKC2Tuple_OutPointScriptZ *NONNULL_PTR orig);
public static native long C2Tuple_OutPointScriptZ_clone(long orig);
// struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
public static native long C2Tuple_OutPointScriptZ_new(long a, byte[] b);
// void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
public static native void C2Tuple_OutPointScriptZ_free(long _res);
+ // uint64_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg);
+ public static native long C2Tuple_u32ScriptZ_clone_ptr(long arg);
// struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_clone(const struct LDKC2Tuple_u32ScriptZ *NONNULL_PTR orig);
public static native long C2Tuple_u32ScriptZ_clone(long orig);
// struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
public static native void C2Tuple_u32ScriptZ_free(long _res);
// void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
public static native void CVec_C2Tuple_u32ScriptZZ_free(long[] _res);
+ // uint64_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg);
+ public static native long C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(long arg);
// struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR orig);
public static native long C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(long orig);
// struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
public static native void CVec_EventZ_free(long[] _res);
// void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
public static native void CVec_TransactionZ_free(byte[][] _res);
+ // uint64_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
+ public static native long C2Tuple_u32TxOutZ_clone_ptr(long arg);
// struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
public static native long C2Tuple_u32TxOutZ_clone(long orig);
// struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
public static native void C2Tuple_u32TxOutZ_free(long _res);
// void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
public static native void CVec_C2Tuple_u32TxOutZZ_free(long[] _res);
+ // uint64_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
+ public static native long C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(long arg);
// struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
public static native long C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(long orig);
// struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
public static native long CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(long o);
// struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(long e);
+ // bool CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(long o);
// void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
public static native void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(long _res);
+ // uint64_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(long orig);
// struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
public static native long CResult_NoneLightningErrorZ_ok();
// struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
public static native long CResult_NoneLightningErrorZ_err(long e);
+ // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_NoneLightningErrorZ_is_ok(long o);
// void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
public static native void CResult_NoneLightningErrorZ_free(long _res);
+ // uint64_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
+ public static native long CResult_NoneLightningErrorZ_clone_ptr(long arg);
// struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
public static native long CResult_NoneLightningErrorZ_clone(long orig);
+ // uint64_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
+ public static native long C2Tuple_PublicKeyTypeZ_clone_ptr(long arg);
// struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
public static native long C2Tuple_PublicKeyTypeZ_clone(long orig);
// struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
public static native long CResult_boolLightningErrorZ_ok(boolean o);
// struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
public static native long CResult_boolLightningErrorZ_err(long e);
+ // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_boolLightningErrorZ_is_ok(long o);
// void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
public static native void CResult_boolLightningErrorZ_free(long _res);
+ // uint64_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
+ public static native long CResult_boolLightningErrorZ_clone_ptr(long arg);
// struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
public static native long CResult_boolLightningErrorZ_clone(long orig);
+ // uint64_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
+ public static native long C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(long arg);
// struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
public static native long C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(long orig);
// struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
public static native long CResult_CVec_u8ZPeerHandleErrorZ_ok(byte[] o);
// struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
public static native long CResult_CVec_u8ZPeerHandleErrorZ_err(long e);
+ // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_CVec_u8ZPeerHandleErrorZ_is_ok(long o);
// void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
public static native void CResult_CVec_u8ZPeerHandleErrorZ_free(long _res);
+ // uint64_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
+ public static native long CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(long arg);
// struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
public static native long CResult_CVec_u8ZPeerHandleErrorZ_clone(long orig);
// struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
public static native long CResult_NonePeerHandleErrorZ_ok();
// struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
public static native long CResult_NonePeerHandleErrorZ_err(long e);
+ // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_NonePeerHandleErrorZ_is_ok(long o);
// void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
public static native void CResult_NonePeerHandleErrorZ_free(long _res);
+ // uint64_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
+ public static native long CResult_NonePeerHandleErrorZ_clone_ptr(long arg);
// struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
public static native long CResult_NonePeerHandleErrorZ_clone(long orig);
// struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
public static native long CResult_boolPeerHandleErrorZ_ok(boolean o);
// struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
public static native long CResult_boolPeerHandleErrorZ_err(long e);
+ // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_boolPeerHandleErrorZ_is_ok(long o);
// void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
public static native void CResult_boolPeerHandleErrorZ_free(long _res);
+ // uint64_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
+ public static native long CResult_boolPeerHandleErrorZ_clone_ptr(long arg);
// struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
public static native long CResult_boolPeerHandleErrorZ_clone(long orig);
// struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
public static native long CResult_NodeIdDecodeErrorZ_ok(long o);
// struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_NodeIdDecodeErrorZ_err(long e);
+ // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_NodeIdDecodeErrorZ_is_ok(long o);
// void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
public static native void CResult_NodeIdDecodeErrorZ_free(long _res);
+ // uint64_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_NodeIdDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_NodeIdDecodeErrorZ_clone(long orig);
+ // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
+ public static native long CResult_COption_NetworkUpdateZDecodeErrorZ_ok(long o);
+ // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
+ public static native long CResult_COption_NetworkUpdateZDecodeErrorZ_err(long e);
+ // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(long o);
+ // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
+ public static native void CResult_COption_NetworkUpdateZDecodeErrorZ_free(long _res);
+ // uint64_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(long arg);
+ // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
+ public static native long CResult_COption_NetworkUpdateZDecodeErrorZ_clone(long orig);
// struct LDKCOption_AccessZ COption_AccessZ_some(struct LDKAccess o);
public static native long COption_AccessZ_some(long o);
// struct LDKCOption_AccessZ COption_AccessZ_none(void);
public static native long CResult_DirectionalChannelInfoDecodeErrorZ_ok(long o);
// struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_DirectionalChannelInfoDecodeErrorZ_err(long e);
+ // bool CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(long o);
// void CResult_DirectionalChannelInfoDecodeErrorZ_free(struct LDKCResult_DirectionalChannelInfoDecodeErrorZ _res);
public static native void CResult_DirectionalChannelInfoDecodeErrorZ_free(long _res);
+ // uint64_t CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_clone(const struct LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_DirectionalChannelInfoDecodeErrorZ_clone(long orig);
// struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
public static native long CResult_ChannelInfoDecodeErrorZ_ok(long o);
// struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_ChannelInfoDecodeErrorZ_err(long e);
+ // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_ChannelInfoDecodeErrorZ_is_ok(long o);
// void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
public static native void CResult_ChannelInfoDecodeErrorZ_free(long _res);
+ // uint64_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_ChannelInfoDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_ChannelInfoDecodeErrorZ_clone(long orig);
// struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
public static native long CResult_RoutingFeesDecodeErrorZ_ok(long o);
// struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_RoutingFeesDecodeErrorZ_err(long e);
+ // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_RoutingFeesDecodeErrorZ_is_ok(long o);
// void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
public static native void CResult_RoutingFeesDecodeErrorZ_free(long _res);
+ // uint64_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_RoutingFeesDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_RoutingFeesDecodeErrorZ_clone(long orig);
// struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
public static native long CResult_NodeAnnouncementInfoDecodeErrorZ_ok(long o);
// struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_NodeAnnouncementInfoDecodeErrorZ_err(long e);
+ // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(long o);
// void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
public static native void CResult_NodeAnnouncementInfoDecodeErrorZ_free(long _res);
+ // uint64_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_NodeAnnouncementInfoDecodeErrorZ_clone(long orig);
// void CVec_u64Z_free(struct LDKCVec_u64Z _res);
public static native long CResult_NodeInfoDecodeErrorZ_ok(long o);
// struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_NodeInfoDecodeErrorZ_err(long e);
+ // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_NodeInfoDecodeErrorZ_is_ok(long o);
// void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
public static native void CResult_NodeInfoDecodeErrorZ_free(long _res);
+ // uint64_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_NodeInfoDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_NodeInfoDecodeErrorZ_clone(long orig);
// struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
public static native long CResult_NetworkGraphDecodeErrorZ_ok(long o);
// struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_NetworkGraphDecodeErrorZ_err(long e);
+ // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_NetworkGraphDecodeErrorZ_is_ok(long o);
// void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
public static native void CResult_NetworkGraphDecodeErrorZ_free(long _res);
+ // uint64_t CResult_NetworkGraphDecodeErrorZ_clone_ptr(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_NetworkGraphDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_clone(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_NetworkGraphDecodeErrorZ_clone(long orig);
// struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_some(struct LDKCVec_NetAddressZ o);
public static native long COption_CVec_NetAddressZZ_none();
// void COption_CVec_NetAddressZZ_free(struct LDKCOption_CVec_NetAddressZZ _res);
public static native void COption_CVec_NetAddressZZ_free(long _res);
+ // uint64_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg);
+ public static native long COption_CVec_NetAddressZZ_clone_ptr(long arg);
// struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_clone(const struct LDKCOption_CVec_NetAddressZZ *NONNULL_PTR orig);
public static native long COption_CVec_NetAddressZZ_clone(long orig);
// struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_ok(struct LDKNetAddress o);
public static native long CResult_NetAddressDecodeErrorZ_ok(long o);
// struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_NetAddressDecodeErrorZ_err(long e);
+ // bool CResult_NetAddressDecodeErrorZ_is_ok(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_NetAddressDecodeErrorZ_is_ok(long o);
// void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
public static native void CResult_NetAddressDecodeErrorZ_free(long _res);
+ // uint64_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_NetAddressDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_NetAddressDecodeErrorZ_clone(long orig);
// void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
public static native long CResult_AcceptChannelDecodeErrorZ_ok(long o);
// struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_AcceptChannelDecodeErrorZ_err(long e);
+ // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_AcceptChannelDecodeErrorZ_is_ok(long o);
// void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
public static native void CResult_AcceptChannelDecodeErrorZ_free(long _res);
+ // uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_AcceptChannelDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_AcceptChannelDecodeErrorZ_clone(long orig);
// struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
public static native long CResult_AnnouncementSignaturesDecodeErrorZ_ok(long o);
// struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_AnnouncementSignaturesDecodeErrorZ_err(long e);
+ // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(long o);
// void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
public static native void CResult_AnnouncementSignaturesDecodeErrorZ_free(long _res);
+ // uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_AnnouncementSignaturesDecodeErrorZ_clone(long orig);
// struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
public static native long CResult_ChannelReestablishDecodeErrorZ_ok(long o);
// struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_ChannelReestablishDecodeErrorZ_err(long e);
+ // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_ChannelReestablishDecodeErrorZ_is_ok(long o);
// void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
public static native void CResult_ChannelReestablishDecodeErrorZ_free(long _res);
+ // uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_ChannelReestablishDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_ChannelReestablishDecodeErrorZ_clone(long orig);
// struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
public static native long CResult_ClosingSignedDecodeErrorZ_ok(long o);
// struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_ClosingSignedDecodeErrorZ_err(long e);
+ // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_ClosingSignedDecodeErrorZ_is_ok(long o);
// void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
public static native void CResult_ClosingSignedDecodeErrorZ_free(long _res);
+ // uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_ClosingSignedDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_ClosingSignedDecodeErrorZ_clone(long orig);
// struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
public static native long CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(long o);
// struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_ClosingSignedFeeRangeDecodeErrorZ_err(long e);
+ // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(long o);
// void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
public static native void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(long _res);
+ // uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(long orig);
// struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
public static native long CResult_CommitmentSignedDecodeErrorZ_ok(long o);
// struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_CommitmentSignedDecodeErrorZ_err(long e);
+ // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_CommitmentSignedDecodeErrorZ_is_ok(long o);
// void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
public static native void CResult_CommitmentSignedDecodeErrorZ_free(long _res);
+ // uint64_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_CommitmentSignedDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_CommitmentSignedDecodeErrorZ_clone(long orig);
// struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
public static native long CResult_FundingCreatedDecodeErrorZ_ok(long o);
// struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_FundingCreatedDecodeErrorZ_err(long e);
+ // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_FundingCreatedDecodeErrorZ_is_ok(long o);
// void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
public static native void CResult_FundingCreatedDecodeErrorZ_free(long _res);
+ // uint64_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_FundingCreatedDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_FundingCreatedDecodeErrorZ_clone(long orig);
// struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
public static native long CResult_FundingSignedDecodeErrorZ_ok(long o);
// struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_FundingSignedDecodeErrorZ_err(long e);
+ // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_FundingSignedDecodeErrorZ_is_ok(long o);
// void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
public static native void CResult_FundingSignedDecodeErrorZ_free(long _res);
+ // uint64_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_FundingSignedDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_FundingSignedDecodeErrorZ_clone(long orig);
// struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_ok(struct LDKFundingLocked o);
public static native long CResult_FundingLockedDecodeErrorZ_ok(long o);
// struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_FundingLockedDecodeErrorZ_err(long e);
+ // bool CResult_FundingLockedDecodeErrorZ_is_ok(const struct LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_FundingLockedDecodeErrorZ_is_ok(long o);
// void CResult_FundingLockedDecodeErrorZ_free(struct LDKCResult_FundingLockedDecodeErrorZ _res);
public static native void CResult_FundingLockedDecodeErrorZ_free(long _res);
+ // uint64_t CResult_FundingLockedDecodeErrorZ_clone_ptr(LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_FundingLockedDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_clone(const struct LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_FundingLockedDecodeErrorZ_clone(long orig);
// struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
public static native long CResult_InitDecodeErrorZ_ok(long o);
// struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_InitDecodeErrorZ_err(long e);
+ // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_InitDecodeErrorZ_is_ok(long o);
// void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
public static native void CResult_InitDecodeErrorZ_free(long _res);
+ // uint64_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_InitDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_InitDecodeErrorZ_clone(long orig);
// struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
public static native long CResult_OpenChannelDecodeErrorZ_ok(long o);
// struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_OpenChannelDecodeErrorZ_err(long e);
+ // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_OpenChannelDecodeErrorZ_is_ok(long o);
// void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
public static native void CResult_OpenChannelDecodeErrorZ_free(long _res);
+ // uint64_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_OpenChannelDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_OpenChannelDecodeErrorZ_clone(long orig);
// struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
public static native long CResult_RevokeAndACKDecodeErrorZ_ok(long o);
// struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_RevokeAndACKDecodeErrorZ_err(long e);
+ // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_RevokeAndACKDecodeErrorZ_is_ok(long o);
// void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
public static native void CResult_RevokeAndACKDecodeErrorZ_free(long _res);
+ // uint64_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_RevokeAndACKDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_RevokeAndACKDecodeErrorZ_clone(long orig);
// struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
public static native long CResult_ShutdownDecodeErrorZ_ok(long o);
// struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_ShutdownDecodeErrorZ_err(long e);
+ // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_ShutdownDecodeErrorZ_is_ok(long o);
// void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
public static native void CResult_ShutdownDecodeErrorZ_free(long _res);
+ // uint64_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_ShutdownDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_ShutdownDecodeErrorZ_clone(long orig);
// struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
public static native long CResult_UpdateFailHTLCDecodeErrorZ_ok(long o);
// struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_UpdateFailHTLCDecodeErrorZ_err(long e);
+ // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_UpdateFailHTLCDecodeErrorZ_is_ok(long o);
// void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
public static native void CResult_UpdateFailHTLCDecodeErrorZ_free(long _res);
+ // uint64_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_UpdateFailHTLCDecodeErrorZ_clone(long orig);
// struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
public static native long CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(long o);
// struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(long e);
+ // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(long o);
// void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
public static native void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(long _res);
+ // uint64_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(long orig);
// struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
public static native long CResult_UpdateFeeDecodeErrorZ_ok(long o);
// struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_UpdateFeeDecodeErrorZ_err(long e);
+ // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_UpdateFeeDecodeErrorZ_is_ok(long o);
// void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
public static native void CResult_UpdateFeeDecodeErrorZ_free(long _res);
+ // uint64_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_UpdateFeeDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_UpdateFeeDecodeErrorZ_clone(long orig);
// struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
public static native long CResult_UpdateFulfillHTLCDecodeErrorZ_ok(long o);
// struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_UpdateFulfillHTLCDecodeErrorZ_err(long e);
+ // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(long o);
// void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
public static native void CResult_UpdateFulfillHTLCDecodeErrorZ_free(long _res);
+ // uint64_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_UpdateFulfillHTLCDecodeErrorZ_clone(long orig);
// struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
public static native long CResult_UpdateAddHTLCDecodeErrorZ_ok(long o);
// struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_UpdateAddHTLCDecodeErrorZ_err(long e);
+ // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_UpdateAddHTLCDecodeErrorZ_is_ok(long o);
// void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
public static native void CResult_UpdateAddHTLCDecodeErrorZ_free(long _res);
+ // uint64_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_UpdateAddHTLCDecodeErrorZ_clone(long orig);
// struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
public static native long CResult_PingDecodeErrorZ_ok(long o);
// struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_PingDecodeErrorZ_err(long e);
+ // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_PingDecodeErrorZ_is_ok(long o);
// void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
public static native void CResult_PingDecodeErrorZ_free(long _res);
+ // uint64_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_PingDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_PingDecodeErrorZ_clone(long orig);
// struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
public static native long CResult_PongDecodeErrorZ_ok(long o);
// struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_PongDecodeErrorZ_err(long e);
+ // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_PongDecodeErrorZ_is_ok(long o);
// void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
public static native void CResult_PongDecodeErrorZ_free(long _res);
+ // uint64_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_PongDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_PongDecodeErrorZ_clone(long orig);
// struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
public static native long CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(long o);
// struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(long e);
+ // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(long o);
// void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
public static native void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(long _res);
+ // uint64_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(long orig);
// struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
public static native long CResult_ChannelAnnouncementDecodeErrorZ_ok(long o);
// struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_ChannelAnnouncementDecodeErrorZ_err(long e);
+ // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_ChannelAnnouncementDecodeErrorZ_is_ok(long o);
// void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
public static native void CResult_ChannelAnnouncementDecodeErrorZ_free(long _res);
+ // uint64_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_ChannelAnnouncementDecodeErrorZ_clone(long orig);
// struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
public static native long CResult_UnsignedChannelUpdateDecodeErrorZ_ok(long o);
// struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_UnsignedChannelUpdateDecodeErrorZ_err(long e);
+ // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(long o);
// void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
public static native void CResult_UnsignedChannelUpdateDecodeErrorZ_free(long _res);
+ // uint64_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_UnsignedChannelUpdateDecodeErrorZ_clone(long orig);
// struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
public static native long CResult_ChannelUpdateDecodeErrorZ_ok(long o);
// struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_ChannelUpdateDecodeErrorZ_err(long e);
+ // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_ChannelUpdateDecodeErrorZ_is_ok(long o);
// void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
public static native void CResult_ChannelUpdateDecodeErrorZ_free(long _res);
+ // uint64_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_ChannelUpdateDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_ChannelUpdateDecodeErrorZ_clone(long orig);
// struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
public static native long CResult_ErrorMessageDecodeErrorZ_ok(long o);
// struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_ErrorMessageDecodeErrorZ_err(long e);
+ // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_ErrorMessageDecodeErrorZ_is_ok(long o);
// void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
public static native void CResult_ErrorMessageDecodeErrorZ_free(long _res);
+ // uint64_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_ErrorMessageDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_ErrorMessageDecodeErrorZ_clone(long orig);
// struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
public static native long CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(long o);
// struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(long e);
+ // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(long o);
// void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
public static native void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(long _res);
+ // uint64_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(long orig);
// struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
public static native long CResult_NodeAnnouncementDecodeErrorZ_ok(long o);
// struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_NodeAnnouncementDecodeErrorZ_err(long e);
+ // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_NodeAnnouncementDecodeErrorZ_is_ok(long o);
// void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
public static native void CResult_NodeAnnouncementDecodeErrorZ_free(long _res);
+ // uint64_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_NodeAnnouncementDecodeErrorZ_clone(long orig);
// struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
public static native long CResult_QueryShortChannelIdsDecodeErrorZ_ok(long o);
// struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_QueryShortChannelIdsDecodeErrorZ_err(long e);
+ // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(long o);
// void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
public static native void CResult_QueryShortChannelIdsDecodeErrorZ_free(long _res);
+ // uint64_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_QueryShortChannelIdsDecodeErrorZ_clone(long orig);
// struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
public static native long CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(long o);
// struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(long e);
+ // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(long o);
// void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
public static native void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(long _res);
+ // uint64_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(long orig);
// struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
public static native long CResult_QueryChannelRangeDecodeErrorZ_ok(long o);
// struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_QueryChannelRangeDecodeErrorZ_err(long e);
+ // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_QueryChannelRangeDecodeErrorZ_is_ok(long o);
// void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
public static native void CResult_QueryChannelRangeDecodeErrorZ_free(long _res);
+ // uint64_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_QueryChannelRangeDecodeErrorZ_clone(long orig);
// struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
public static native long CResult_ReplyChannelRangeDecodeErrorZ_ok(long o);
// struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_ReplyChannelRangeDecodeErrorZ_err(long e);
+ // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_ReplyChannelRangeDecodeErrorZ_is_ok(long o);
// void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
public static native void CResult_ReplyChannelRangeDecodeErrorZ_free(long _res);
+ // uint64_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_ReplyChannelRangeDecodeErrorZ_clone(long orig);
// struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
public static native long CResult_GossipTimestampFilterDecodeErrorZ_ok(long o);
// struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
public static native long CResult_GossipTimestampFilterDecodeErrorZ_err(long e);
+ // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_GossipTimestampFilterDecodeErrorZ_is_ok(long o);
// void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
public static native void CResult_GossipTimestampFilterDecodeErrorZ_free(long _res);
+ // uint64_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(long arg);
// struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
public static native long CResult_GossipTimestampFilterDecodeErrorZ_clone(long orig);
// struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_ok(struct LDKInvoice o);
public static native long CResult_InvoiceSignOrCreationErrorZ_ok(long o);
// struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
public static native long CResult_InvoiceSignOrCreationErrorZ_err(long e);
+ // bool CResult_InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_InvoiceSignOrCreationErrorZ_is_ok(long o);
// void CResult_InvoiceSignOrCreationErrorZ_free(struct LDKCResult_InvoiceSignOrCreationErrorZ _res);
public static native void CResult_InvoiceSignOrCreationErrorZ_free(long _res);
+ // uint64_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
+ public static native long CResult_InvoiceSignOrCreationErrorZ_clone_ptr(long arg);
// struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
public static native long CResult_InvoiceSignOrCreationErrorZ_clone(long orig);
// struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
public static native long CResult_LockedChannelMonitorNoneZ_ok(long o);
// struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
public static native long CResult_LockedChannelMonitorNoneZ_err();
+ // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_LockedChannelMonitorNoneZ_is_ok(long o);
// void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
public static native void CResult_LockedChannelMonitorNoneZ_free(long _res);
// void CVec_OutPointZ_free(struct LDKCVec_OutPointZ _res);
public static native void CVec_OutPointZ_free(long[] _res);
// void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
public static native void PaymentPurpose_free(long this_ptr);
+ // uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
+ public static native long PaymentPurpose_clone_ptr(long arg);
// struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
public static native long PaymentPurpose_clone(long orig);
// struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret, uint64_t user_payment_id);
public static native long PaymentPurpose_spontaneous_payment(byte[] a);
// void ClosureReason_free(struct LDKClosureReason this_ptr);
public static native void ClosureReason_free(long this_ptr);
+ // uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
+ public static native long ClosureReason_clone_ptr(long arg);
// struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
public static native long ClosureReason_clone(long orig);
// struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKStr peer_msg);
public static native long ClosureReason_outdated_channel_manager();
// struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
public static native byte[] ClosureReason_write(long obj);
+ // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
+ public static native long ClosureReason_read(byte[] ser);
// void Event_free(struct LDKEvent this_ptr);
public static native void Event_free(long this_ptr);
+ // uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
+ public static native long Event_clone_ptr(long arg);
// struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
public static native long Event_clone(long orig);
// struct LDKEvent Event_funding_generation_ready(struct LDKThirtyTwoBytes temporary_channel_id, uint64_t channel_value_satoshis, struct LDKCVec_u8Z output_script, uint64_t user_channel_id);
public static native long Event_discard_funding(byte[] channel_id, byte[] transaction);
// struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
public static native byte[] Event_write(long obj);
+ // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
+ public static native long Event_read(byte[] ser);
// void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
public static native void MessageSendEvent_free(long this_ptr);
+ // uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
+ public static native long MessageSendEvent_clone_ptr(long arg);
// struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
public static native long MessageSendEvent_clone(long orig);
// struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
public static native void EventHandler_free(long this_ptr);
// void APIError_free(struct LDKAPIError this_ptr);
public static native void APIError_free(long this_ptr);
+ // uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
+ public static native long APIError_clone_ptr(long arg);
// struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
public static native long APIError_clone(long orig);
// struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
public static native long Level_hash(long o);
// MUST_USE_RES enum LDKLevel Level_max(void);
public static native Level Level_max();
+ // void Record_free(struct LDKRecord this_obj);
+ public static native void Record_free(long this_obj);
+ // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
+ public static native Level Record_get_level(long this_ptr);
+ // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
+ public static native void Record_set_level(long this_ptr, Level val);
+ // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
+ public static native String Record_get_args(long this_ptr);
+ // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
+ public static native void Record_set_args(long this_ptr, String val);
+ // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
+ public static native String Record_get_module_path(long this_ptr);
+ // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
+ public static native void Record_set_module_path(long this_ptr, String val);
+ // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
+ public static native String Record_get_file(long this_ptr);
+ // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
+ public static native void Record_set_file(long this_ptr, String val);
+ // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
+ public static native int Record_get_line(long this_ptr);
+ // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
+ public static native void Record_set_line(long this_ptr, int val);
+ // uint64_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
+ public static native long Record_clone_ptr(long arg);
+ // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
+ public static native long Record_clone(long orig);
// void Logger_free(struct LDKLogger this_ptr);
public static native void Logger_free(long this_ptr);
// void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
public static native void ChannelHandshakeConfig_set_our_htlc_minimum_msat(long this_ptr, long val);
// MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_new(uint32_t minimum_depth_arg, uint16_t our_to_self_delay_arg, uint64_t our_htlc_minimum_msat_arg);
public static native long ChannelHandshakeConfig_new(int minimum_depth_arg, short our_to_self_delay_arg, long our_htlc_minimum_msat_arg);
+ // uint64_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
+ public static native long ChannelHandshakeConfig_clone_ptr(long arg);
// struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
public static native long ChannelHandshakeConfig_clone(long orig);
// MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
public static native void ChannelHandshakeLimits_set_their_to_self_delay(long this_ptr, short val);
// MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_new(uint64_t min_funding_satoshis_arg, uint64_t max_htlc_minimum_msat_arg, uint64_t min_max_htlc_value_in_flight_msat_arg, uint64_t max_channel_reserve_satoshis_arg, uint16_t min_max_accepted_htlcs_arg, uint32_t max_minimum_depth_arg, bool force_announced_channel_preference_arg, uint16_t their_to_self_delay_arg);
public static native long ChannelHandshakeLimits_new(long min_funding_satoshis_arg, long max_htlc_minimum_msat_arg, long min_max_htlc_value_in_flight_msat_arg, long max_channel_reserve_satoshis_arg, short min_max_accepted_htlcs_arg, int max_minimum_depth_arg, boolean force_announced_channel_preference_arg, short their_to_self_delay_arg);
+ // uint64_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
+ public static native long ChannelHandshakeLimits_clone_ptr(long arg);
// struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
public static native long ChannelHandshakeLimits_clone(long orig);
// MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
public static native void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(long this_ptr, long val);
// MUST_USE_RES struct LDKChannelConfig ChannelConfig_new(uint32_t forwarding_fee_proportional_millionths_arg, uint32_t forwarding_fee_base_msat_arg, uint16_t cltv_expiry_delta_arg, bool announced_channel_arg, bool commit_upfront_shutdown_pubkey_arg, uint64_t max_dust_htlc_exposure_msat_arg, uint64_t force_close_avoidance_max_fee_satoshis_arg);
public static native long ChannelConfig_new(int forwarding_fee_proportional_millionths_arg, int forwarding_fee_base_msat_arg, short cltv_expiry_delta_arg, boolean announced_channel_arg, boolean commit_upfront_shutdown_pubkey_arg, long max_dust_htlc_exposure_msat_arg, long force_close_avoidance_max_fee_satoshis_arg);
+ // uint64_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
+ public static native long ChannelConfig_clone_ptr(long arg);
// struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
public static native long ChannelConfig_clone(long orig);
// MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
public static native void UserConfig_set_accept_forwards_to_priv_channels(long this_ptr, boolean val);
// MUST_USE_RES struct LDKUserConfig UserConfig_new(struct LDKChannelHandshakeConfig own_channel_config_arg, struct LDKChannelHandshakeLimits peer_channel_config_limits_arg, struct LDKChannelConfig channel_options_arg, bool accept_forwards_to_priv_channels_arg);
public static native long UserConfig_new(long own_channel_config_arg, long peer_channel_config_limits_arg, long channel_options_arg, boolean accept_forwards_to_priv_channels_arg);
+ // uint64_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
+ public static native long UserConfig_clone_ptr(long arg);
// struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
public static native long UserConfig_clone(long orig);
// MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
public static native long UserConfig_default();
// void BestBlock_free(struct LDKBestBlock this_obj);
public static native void BestBlock_free(long this_obj);
+ // uint64_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
+ public static native long BestBlock_clone_ptr(long arg);
// struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
public static native long BestBlock_clone(long orig);
// MUST_USE_RES struct LDKBestBlock BestBlock_from_genesis(enum LDKNetwork network);
public static native void WatchedOutput_set_script_pubkey(long this_ptr, byte[] val);
// MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKThirtyTwoBytes block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
public static native long WatchedOutput_new(byte[] block_hash_arg, long outpoint_arg, byte[] script_pubkey_arg);
+ // uint64_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
+ public static native long WatchedOutput_clone_ptr(long arg);
// struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
public static native long WatchedOutput_clone(long orig);
// uint64_t WatchedOutput_hash(const struct LDKWatchedOutput *NONNULL_PTR o);
public static native void FeeEstimator_free(long this_ptr);
// void MonitorUpdateId_free(struct LDKMonitorUpdateId this_obj);
public static native void MonitorUpdateId_free(long this_obj);
+ // uint64_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
+ public static native long MonitorUpdateId_clone_ptr(long arg);
// struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
public static native long MonitorUpdateId_clone(long orig);
// uint64_t MonitorUpdateId_hash(const struct LDKMonitorUpdateId *NONNULL_PTR o);
public static native long ChannelMonitorUpdate_get_update_id(long this_ptr);
// void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
public static native void ChannelMonitorUpdate_set_update_id(long this_ptr, long val);
+ // uint64_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
+ public static native long ChannelMonitorUpdate_clone_ptr(long arg);
// struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
public static native long ChannelMonitorUpdate_clone(long orig);
// struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
public static native void MonitorUpdateError_set_a(long this_ptr, String val);
// MUST_USE_RES struct LDKMonitorUpdateError MonitorUpdateError_new(struct LDKStr a_arg);
public static native long MonitorUpdateError_new(String a_arg);
+ // uint64_t MonitorUpdateError_clone_ptr(LDKMonitorUpdateError *NONNULL_PTR arg);
+ public static native long MonitorUpdateError_clone_ptr(long arg);
// struct LDKMonitorUpdateError MonitorUpdateError_clone(const struct LDKMonitorUpdateError *NONNULL_PTR orig);
public static native long MonitorUpdateError_clone(long orig);
// void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
public static native void MonitorEvent_free(long this_ptr);
+ // uint64_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
+ public static native long MonitorEvent_clone_ptr(long arg);
// struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
public static native long MonitorEvent_clone(long orig);
// struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
public static native long MonitorEvent_update_failed(long a);
// struct LDKCVec_u8Z MonitorEvent_write(const struct LDKMonitorEvent *NONNULL_PTR obj);
public static native byte[] MonitorEvent_write(long obj);
+ // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
+ public static native long MonitorEvent_read(byte[] ser);
// void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
public static native void HTLCUpdate_free(long this_obj);
+ // uint64_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
+ public static native long HTLCUpdate_clone_ptr(long arg);
// struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
public static native long HTLCUpdate_clone(long orig);
// struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
public static native long HTLCUpdate_read(byte[] ser);
// void Balance_free(struct LDKBalance this_ptr);
public static native void Balance_free(long this_ptr);
+ // uint64_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
+ public static native long Balance_clone_ptr(long arg);
// struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
public static native long Balance_clone(long orig);
// struct LDKBalance Balance_claimable_on_channel_close(uint64_t claimable_amount_satoshis);
public static native boolean Balance_eq(long a, long b);
// void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
public static native void ChannelMonitor_free(long this_obj);
+ // uint64_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
+ public static native long ChannelMonitor_clone_ptr(long arg);
// struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
public static native long ChannelMonitor_clone(long orig);
// struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
public static native void OutPoint_set_index(long this_ptr, short val);
// MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
public static native long OutPoint_new(byte[] txid_arg, short index_arg);
+ // uint64_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
+ public static native long OutPoint_clone_ptr(long arg);
// struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
public static native long OutPoint_clone(long orig);
// bool OutPoint_eq(const struct LDKOutPoint *NONNULL_PTR a, const struct LDKOutPoint *NONNULL_PTR b);
public static native void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(long this_ptr, long val);
// MUST_USE_RES struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_new(struct LDKOutPoint outpoint_arg, struct LDKPublicKey per_commitment_point_arg, uint16_t to_self_delay_arg, struct LDKTxOut output_arg, struct LDKPublicKey revocation_pubkey_arg, struct LDKThirtyTwoBytes channel_keys_id_arg, uint64_t channel_value_satoshis_arg);
public static native long DelayedPaymentOutputDescriptor_new(long outpoint_arg, byte[] per_commitment_point_arg, short to_self_delay_arg, long output_arg, byte[] revocation_pubkey_arg, byte[] channel_keys_id_arg, long channel_value_satoshis_arg);
+ // uint64_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
+ public static native long DelayedPaymentOutputDescriptor_clone_ptr(long arg);
// struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
public static native long DelayedPaymentOutputDescriptor_clone(long orig);
// struct LDKCVec_u8Z DelayedPaymentOutputDescriptor_write(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR obj);
public static native void StaticPaymentOutputDescriptor_set_channel_value_satoshis(long this_ptr, long val);
// MUST_USE_RES struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_new(struct LDKOutPoint outpoint_arg, struct LDKTxOut output_arg, struct LDKThirtyTwoBytes channel_keys_id_arg, uint64_t channel_value_satoshis_arg);
public static native long StaticPaymentOutputDescriptor_new(long outpoint_arg, long output_arg, byte[] channel_keys_id_arg, long channel_value_satoshis_arg);
+ // uint64_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
+ public static native long StaticPaymentOutputDescriptor_clone_ptr(long arg);
// struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
public static native long StaticPaymentOutputDescriptor_clone(long orig);
// struct LDKCVec_u8Z StaticPaymentOutputDescriptor_write(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR obj);
public static native long StaticPaymentOutputDescriptor_read(byte[] ser);
// void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
public static native void SpendableOutputDescriptor_free(long this_ptr);
+ // uint64_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
+ public static native long SpendableOutputDescriptor_clone_ptr(long arg);
// struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
public static native long SpendableOutputDescriptor_clone(long orig);
// struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output);
public static native long SpendableOutputDescriptor_read(byte[] ser);
// void BaseSign_free(struct LDKBaseSign this_ptr);
public static native void BaseSign_free(long this_ptr);
+ // uint64_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg);
+ public static native long Sign_clone_ptr(long arg);
// struct LDKSign Sign_clone(const struct LDKSign *NONNULL_PTR orig);
public static native long Sign_clone(long orig);
// void Sign_free(struct LDKSign this_ptr);
public static native byte[] InMemorySigner_get_commitment_seed(long this_ptr);
// void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
public static native void InMemorySigner_set_commitment_seed(long this_ptr, byte[] val);
+ // uint64_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
+ public static native long InMemorySigner_clone_ptr(long arg);
// struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
public static native long InMemorySigner_clone(long orig);
// MUST_USE_RES struct LDKInMemorySigner InMemorySigner_new(struct LDKSecretKey funding_key, struct LDKSecretKey revocation_base_key, struct LDKSecretKey payment_key, struct LDKSecretKey delayed_payment_base_key, struct LDKSecretKey htlc_base_key, struct LDKThirtyTwoBytes commitment_seed, uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id);
public static native void ChainParameters_set_best_block(long this_ptr, long val);
// MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
public static native long ChainParameters_new(Network network_arg, long best_block_arg);
+ // uint64_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
+ public static native long ChainParameters_clone_ptr(long arg);
// struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
public static native long ChainParameters_clone(long orig);
// void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
public static native void CounterpartyForwardingInfo_set_cltv_expiry_delta(long this_ptr, short val);
// MUST_USE_RES struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_new(uint32_t fee_base_msat_arg, uint32_t fee_proportional_millionths_arg, uint16_t cltv_expiry_delta_arg);
public static native long CounterpartyForwardingInfo_new(int fee_base_msat_arg, int fee_proportional_millionths_arg, short cltv_expiry_delta_arg);
+ // uint64_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
+ public static native long CounterpartyForwardingInfo_clone_ptr(long arg);
// struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
public static native long CounterpartyForwardingInfo_clone(long orig);
// void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
public static native void ChannelCounterparty_set_forwarding_info(long this_ptr, long val);
// MUST_USE_RES struct LDKChannelCounterparty ChannelCounterparty_new(struct LDKPublicKey node_id_arg, struct LDKInitFeatures features_arg, uint64_t unspendable_punishment_reserve_arg, struct LDKCounterpartyForwardingInfo forwarding_info_arg);
public static native long ChannelCounterparty_new(byte[] node_id_arg, long features_arg, long unspendable_punishment_reserve_arg, long forwarding_info_arg);
+ // uint64_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
+ public static native long ChannelCounterparty_clone_ptr(long arg);
// struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
public static native long ChannelCounterparty_clone(long orig);
// void ChannelDetails_free(struct LDKChannelDetails this_obj);
public static native void ChannelDetails_set_is_public(long this_ptr, boolean val);
// MUST_USE_RES struct LDKChannelDetails ChannelDetails_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKChannelCounterparty counterparty_arg, struct LDKOutPoint funding_txo_arg, struct LDKCOption_u64Z short_channel_id_arg, uint64_t channel_value_satoshis_arg, struct LDKCOption_u64Z unspendable_punishment_reserve_arg, uint64_t user_channel_id_arg, uint64_t outbound_capacity_msat_arg, uint64_t inbound_capacity_msat_arg, struct LDKCOption_u32Z confirmations_required_arg, struct LDKCOption_u16Z force_close_spend_delay_arg, bool is_outbound_arg, bool is_funding_locked_arg, bool is_usable_arg, bool is_public_arg);
public static native long ChannelDetails_new(byte[] channel_id_arg, long counterparty_arg, long funding_txo_arg, long short_channel_id_arg, long channel_value_satoshis_arg, long unspendable_punishment_reserve_arg, long user_channel_id_arg, long outbound_capacity_msat_arg, long inbound_capacity_msat_arg, long confirmations_required_arg, long force_close_spend_delay_arg, boolean is_outbound_arg, boolean is_funding_locked_arg, boolean is_usable_arg, boolean is_public_arg);
+ // uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
+ public static native long ChannelDetails_clone_ptr(long arg);
// struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
public static native long ChannelDetails_clone(long orig);
// void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
public static native void PaymentSendFailure_free(long this_ptr);
+ // uint64_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
+ public static native long PaymentSendFailure_clone_ptr(long arg);
// struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
public static native long PaymentSendFailure_clone(long orig);
// struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
public static native long C2Tuple_BlockHashChannelManagerZ_read(byte[] ser, long arg);
// void DecodeError_free(struct LDKDecodeError this_obj);
public static native void DecodeError_free(long this_obj);
+ // uint64_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
+ public static native long DecodeError_clone_ptr(long arg);
// struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
public static native long DecodeError_clone(long orig);
// void Init_free(struct LDKInit this_obj);
public static native void Init_set_features(long this_ptr, long val);
// MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg);
public static native long Init_new(long features_arg);
+ // uint64_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
+ public static native long Init_clone_ptr(long arg);
// struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
public static native long Init_clone(long orig);
// void ErrorMessage_free(struct LDKErrorMessage this_obj);
public static native void ErrorMessage_set_data(long this_ptr, String val);
// MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
public static native long ErrorMessage_new(byte[] channel_id_arg, String data_arg);
+ // uint64_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
+ public static native long ErrorMessage_clone_ptr(long arg);
// struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
public static native long ErrorMessage_clone(long orig);
// void Ping_free(struct LDKPing this_obj);
public static native void Ping_set_byteslen(long this_ptr, short val);
// MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
public static native long Ping_new(short ponglen_arg, short byteslen_arg);
+ // uint64_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
+ public static native long Ping_clone_ptr(long arg);
// struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
public static native long Ping_clone(long orig);
// void Pong_free(struct LDKPong this_obj);
public static native void Pong_set_byteslen(long this_ptr, short val);
// MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
public static native long Pong_new(short byteslen_arg);
+ // uint64_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
+ public static native long Pong_clone_ptr(long arg);
// struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
public static native long Pong_clone(long orig);
// void OpenChannel_free(struct LDKOpenChannel this_obj);
public static native byte OpenChannel_get_channel_flags(long this_ptr);
// void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
public static native void OpenChannel_set_channel_flags(long this_ptr, byte val);
+ // uint64_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
+ public static native long OpenChannel_clone_ptr(long arg);
// struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
public static native long OpenChannel_clone(long orig);
// void AcceptChannel_free(struct LDKAcceptChannel this_obj);
public static native byte[] AcceptChannel_get_first_per_commitment_point(long this_ptr);
// void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
public static native void AcceptChannel_set_first_per_commitment_point(long this_ptr, byte[] val);
+ // uint64_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
+ public static native long AcceptChannel_clone_ptr(long arg);
// struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
public static native long AcceptChannel_clone(long orig);
// void FundingCreated_free(struct LDKFundingCreated this_obj);
public static native void FundingCreated_set_signature(long this_ptr, byte[] val);
// MUST_USE_RES struct LDKFundingCreated FundingCreated_new(struct LDKThirtyTwoBytes temporary_channel_id_arg, struct LDKThirtyTwoBytes funding_txid_arg, uint16_t funding_output_index_arg, struct LDKSignature signature_arg);
public static native long FundingCreated_new(byte[] temporary_channel_id_arg, byte[] funding_txid_arg, short funding_output_index_arg, byte[] signature_arg);
+ // uint64_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
+ public static native long FundingCreated_clone_ptr(long arg);
// struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
public static native long FundingCreated_clone(long orig);
// void FundingSigned_free(struct LDKFundingSigned this_obj);
public static native void FundingSigned_set_signature(long this_ptr, byte[] val);
// MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg);
public static native long FundingSigned_new(byte[] channel_id_arg, byte[] signature_arg);
+ // uint64_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
+ public static native long FundingSigned_clone_ptr(long arg);
// struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
public static native long FundingSigned_clone(long orig);
// void FundingLocked_free(struct LDKFundingLocked this_obj);
public static native void FundingLocked_set_next_per_commitment_point(long this_ptr, byte[] val);
// MUST_USE_RES struct LDKFundingLocked FundingLocked_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKPublicKey next_per_commitment_point_arg);
public static native long FundingLocked_new(byte[] channel_id_arg, byte[] next_per_commitment_point_arg);
+ // uint64_t FundingLocked_clone_ptr(LDKFundingLocked *NONNULL_PTR arg);
+ public static native long FundingLocked_clone_ptr(long arg);
// struct LDKFundingLocked FundingLocked_clone(const struct LDKFundingLocked *NONNULL_PTR orig);
public static native long FundingLocked_clone(long orig);
// void Shutdown_free(struct LDKShutdown this_obj);
public static native void Shutdown_set_scriptpubkey(long this_ptr, byte[] val);
// MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
public static native long Shutdown_new(byte[] channel_id_arg, byte[] scriptpubkey_arg);
+ // uint64_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
+ public static native long Shutdown_clone_ptr(long arg);
// struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
public static native long Shutdown_clone(long orig);
// void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
public static native void ClosingSignedFeeRange_set_max_fee_satoshis(long this_ptr, long val);
// MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
public static native long ClosingSignedFeeRange_new(long min_fee_satoshis_arg, long max_fee_satoshis_arg);
+ // uint64_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
+ public static native long ClosingSignedFeeRange_clone_ptr(long arg);
// struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
public static native long ClosingSignedFeeRange_clone(long orig);
// void ClosingSigned_free(struct LDKClosingSigned this_obj);
public static native void ClosingSigned_set_fee_range(long this_ptr, long val);
// MUST_USE_RES struct LDKClosingSigned ClosingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t fee_satoshis_arg, struct LDKSignature signature_arg, struct LDKClosingSignedFeeRange fee_range_arg);
public static native long ClosingSigned_new(byte[] channel_id_arg, long fee_satoshis_arg, byte[] signature_arg, long fee_range_arg);
+ // uint64_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
+ public static native long ClosingSigned_clone_ptr(long arg);
// struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
public static native long ClosingSigned_clone(long orig);
// void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
public static native int UpdateAddHTLC_get_cltv_expiry(long this_ptr);
// void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
public static native void UpdateAddHTLC_set_cltv_expiry(long this_ptr, int val);
+ // uint64_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
+ public static native long UpdateAddHTLC_clone_ptr(long arg);
// struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
public static native long UpdateAddHTLC_clone(long orig);
// void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
public static native void UpdateFulfillHTLC_set_payment_preimage(long this_ptr, byte[] val);
// MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
public static native long UpdateFulfillHTLC_new(byte[] channel_id_arg, long htlc_id_arg, byte[] payment_preimage_arg);
+ // uint64_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
+ public static native long UpdateFulfillHTLC_clone_ptr(long arg);
// struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
public static native long UpdateFulfillHTLC_clone(long orig);
// void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
public static native long UpdateFailHTLC_get_htlc_id(long this_ptr);
// void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
public static native void UpdateFailHTLC_set_htlc_id(long this_ptr, long val);
+ // uint64_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
+ public static native long UpdateFailHTLC_clone_ptr(long arg);
// struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
public static native long UpdateFailHTLC_clone(long orig);
// void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
public static native short UpdateFailMalformedHTLC_get_failure_code(long this_ptr);
// void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
public static native void UpdateFailMalformedHTLC_set_failure_code(long this_ptr, short val);
+ // uint64_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
+ public static native long UpdateFailMalformedHTLC_clone_ptr(long arg);
// struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
public static native long UpdateFailMalformedHTLC_clone(long orig);
// void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
public static native void CommitmentSigned_set_htlc_signatures(long this_ptr, byte[][] val);
// MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg, struct LDKCVec_SignatureZ htlc_signatures_arg);
public static native long CommitmentSigned_new(byte[] channel_id_arg, byte[] signature_arg, byte[][] htlc_signatures_arg);
+ // uint64_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
+ public static native long CommitmentSigned_clone_ptr(long arg);
// struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
public static native long CommitmentSigned_clone(long orig);
// void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
public static native void RevokeAndACK_set_next_per_commitment_point(long this_ptr, byte[] val);
// MUST_USE_RES struct LDKRevokeAndACK RevokeAndACK_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKThirtyTwoBytes per_commitment_secret_arg, struct LDKPublicKey next_per_commitment_point_arg);
public static native long RevokeAndACK_new(byte[] channel_id_arg, byte[] per_commitment_secret_arg, byte[] next_per_commitment_point_arg);
+ // uint64_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
+ public static native long RevokeAndACK_clone_ptr(long arg);
// struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
public static native long RevokeAndACK_clone(long orig);
// void UpdateFee_free(struct LDKUpdateFee this_obj);
public static native void UpdateFee_set_feerate_per_kw(long this_ptr, int val);
// MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
public static native long UpdateFee_new(byte[] channel_id_arg, int feerate_per_kw_arg);
+ // uint64_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
+ public static native long UpdateFee_clone_ptr(long arg);
// struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
public static native long UpdateFee_clone(long orig);
// void DataLossProtect_free(struct LDKDataLossProtect this_obj);
public static native void DataLossProtect_set_my_current_per_commitment_point(long this_ptr, byte[] val);
// MUST_USE_RES struct LDKDataLossProtect DataLossProtect_new(struct LDKThirtyTwoBytes your_last_per_commitment_secret_arg, struct LDKPublicKey my_current_per_commitment_point_arg);
public static native long DataLossProtect_new(byte[] your_last_per_commitment_secret_arg, byte[] my_current_per_commitment_point_arg);
+ // uint64_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg);
+ public static native long DataLossProtect_clone_ptr(long arg);
// struct LDKDataLossProtect DataLossProtect_clone(const struct LDKDataLossProtect *NONNULL_PTR orig);
public static native long DataLossProtect_clone(long orig);
// void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
public static native long ChannelReestablish_get_next_remote_commitment_number(long this_ptr);
// void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
public static native void ChannelReestablish_set_next_remote_commitment_number(long this_ptr, long val);
+ // uint64_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
+ public static native long ChannelReestablish_clone_ptr(long arg);
// struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
public static native long ChannelReestablish_clone(long orig);
// void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
public static native void AnnouncementSignatures_set_bitcoin_signature(long this_ptr, byte[] val);
// MUST_USE_RES struct LDKAnnouncementSignatures AnnouncementSignatures_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t short_channel_id_arg, struct LDKSignature node_signature_arg, struct LDKSignature bitcoin_signature_arg);
public static native long AnnouncementSignatures_new(byte[] channel_id_arg, long short_channel_id_arg, byte[] node_signature_arg, byte[] bitcoin_signature_arg);
+ // uint64_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
+ public static native long AnnouncementSignatures_clone_ptr(long arg);
// struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
public static native long AnnouncementSignatures_clone(long orig);
// void NetAddress_free(struct LDKNetAddress this_ptr);
public static native void NetAddress_free(long this_ptr);
+ // uint64_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg);
+ public static native long NetAddress_clone_ptr(long arg);
// struct LDKNetAddress NetAddress_clone(const struct LDKNetAddress *NONNULL_PTR orig);
public static native long NetAddress_clone(long orig);
// struct LDKNetAddress NetAddress_ipv4(struct LDKFourBytes addr, uint16_t port);
public static native void UnsignedNodeAnnouncement_set_alias(long this_ptr, byte[] val);
// void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
public static native void UnsignedNodeAnnouncement_set_addresses(long this_ptr, long[] val);
+ // uint64_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
+ public static native long UnsignedNodeAnnouncement_clone_ptr(long arg);
// struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
public static native long UnsignedNodeAnnouncement_clone(long orig);
// void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
public static native void NodeAnnouncement_set_contents(long this_ptr, long val);
// MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKSignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
public static native long NodeAnnouncement_new(byte[] signature_arg, long contents_arg);
+ // uint64_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
+ public static native long NodeAnnouncement_clone_ptr(long arg);
// struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
public static native long NodeAnnouncement_clone(long orig);
// void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
public static native byte[] UnsignedChannelAnnouncement_get_bitcoin_key_2(long this_ptr);
// void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
public static native void UnsignedChannelAnnouncement_set_bitcoin_key_2(long this_ptr, byte[] val);
+ // uint64_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
+ public static native long UnsignedChannelAnnouncement_clone_ptr(long arg);
// struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
public static native long UnsignedChannelAnnouncement_clone(long orig);
// void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
public static native void ChannelAnnouncement_set_contents(long this_ptr, long val);
// MUST_USE_RES struct LDKChannelAnnouncement ChannelAnnouncement_new(struct LDKSignature node_signature_1_arg, struct LDKSignature node_signature_2_arg, struct LDKSignature bitcoin_signature_1_arg, struct LDKSignature bitcoin_signature_2_arg, struct LDKUnsignedChannelAnnouncement contents_arg);
public static native long ChannelAnnouncement_new(byte[] node_signature_1_arg, byte[] node_signature_2_arg, byte[] bitcoin_signature_1_arg, byte[] bitcoin_signature_2_arg, long contents_arg);
+ // uint64_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
+ public static native long ChannelAnnouncement_clone_ptr(long arg);
// struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
public static native long ChannelAnnouncement_clone(long orig);
// void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
public static native int UnsignedChannelUpdate_get_fee_proportional_millionths(long this_ptr);
// void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
public static native void UnsignedChannelUpdate_set_fee_proportional_millionths(long this_ptr, int val);
+ // uint64_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
+ public static native long UnsignedChannelUpdate_clone_ptr(long arg);
// struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
public static native long UnsignedChannelUpdate_clone(long orig);
// void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
public static native void ChannelUpdate_set_contents(long this_ptr, long val);
// MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKSignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
public static native long ChannelUpdate_new(byte[] signature_arg, long contents_arg);
+ // uint64_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
+ public static native long ChannelUpdate_clone_ptr(long arg);
// struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
public static native long ChannelUpdate_clone(long orig);
// void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
public static native void QueryChannelRange_set_number_of_blocks(long this_ptr, int val);
// MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
public static native long QueryChannelRange_new(byte[] chain_hash_arg, int first_blocknum_arg, int number_of_blocks_arg);
+ // uint64_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
+ public static native long QueryChannelRange_clone_ptr(long arg);
// struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
public static native long QueryChannelRange_clone(long orig);
// void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
public static native void ReplyChannelRange_set_short_channel_ids(long this_ptr, long[] val);
// MUST_USE_RES struct LDKReplyChannelRange ReplyChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg, bool sync_complete_arg, struct LDKCVec_u64Z short_channel_ids_arg);
public static native long ReplyChannelRange_new(byte[] chain_hash_arg, int first_blocknum_arg, int number_of_blocks_arg, boolean sync_complete_arg, long[] short_channel_ids_arg);
+ // uint64_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
+ public static native long ReplyChannelRange_clone_ptr(long arg);
// struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
public static native long ReplyChannelRange_clone(long orig);
// void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
public static native void QueryShortChannelIds_set_short_channel_ids(long this_ptr, long[] val);
// MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
public static native long QueryShortChannelIds_new(byte[] chain_hash_arg, long[] short_channel_ids_arg);
+ // uint64_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
+ public static native long QueryShortChannelIds_clone_ptr(long arg);
// struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
public static native long QueryShortChannelIds_clone(long orig);
// void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
public static native void ReplyShortChannelIdsEnd_set_full_information(long this_ptr, boolean val);
// MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
public static native long ReplyShortChannelIdsEnd_new(byte[] chain_hash_arg, boolean full_information_arg);
+ // uint64_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
+ public static native long ReplyShortChannelIdsEnd_clone_ptr(long arg);
// struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
public static native long ReplyShortChannelIdsEnd_clone(long orig);
// void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
public static native void GossipTimestampFilter_set_timestamp_range(long this_ptr, int val);
// MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
public static native long GossipTimestampFilter_new(byte[] chain_hash_arg, int first_timestamp_arg, int timestamp_range_arg);
+ // uint64_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
+ public static native long GossipTimestampFilter_clone_ptr(long arg);
// struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
public static native long GossipTimestampFilter_clone(long orig);
// void ErrorAction_free(struct LDKErrorAction this_ptr);
public static native void ErrorAction_free(long this_ptr);
+ // uint64_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
+ public static native long ErrorAction_clone_ptr(long arg);
// struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
public static native long ErrorAction_clone(long orig);
// struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
public static native void LightningError_set_action(long this_ptr, long val);
// MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKStr err_arg, struct LDKErrorAction action_arg);
public static native long LightningError_new(String err_arg, long action_arg);
+ // uint64_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
+ public static native long LightningError_clone_ptr(long arg);
// struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
public static native long LightningError_clone(long orig);
// void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
public static native void CommitmentUpdate_set_commitment_signed(long this_ptr, long val);
// MUST_USE_RES struct LDKCommitmentUpdate CommitmentUpdate_new(struct LDKCVec_UpdateAddHTLCZ update_add_htlcs_arg, struct LDKCVec_UpdateFulfillHTLCZ update_fulfill_htlcs_arg, struct LDKCVec_UpdateFailHTLCZ update_fail_htlcs_arg, struct LDKCVec_UpdateFailMalformedHTLCZ update_fail_malformed_htlcs_arg, struct LDKUpdateFee update_fee_arg, struct LDKCommitmentSigned commitment_signed_arg);
public static native long CommitmentUpdate_new(long[] update_add_htlcs_arg, long[] update_fulfill_htlcs_arg, long[] update_fail_htlcs_arg, long[] update_fail_malformed_htlcs_arg, long update_fee_arg, long commitment_signed_arg);
+ // uint64_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
+ public static native long CommitmentUpdate_clone_ptr(long arg);
// struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
public static native long CommitmentUpdate_clone(long orig);
// void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
public static native void MessageHandler_set_route_handler(long this_ptr, long val);
// MUST_USE_RES struct LDKMessageHandler MessageHandler_new(struct LDKChannelMessageHandler chan_handler_arg, struct LDKRoutingMessageHandler route_handler_arg);
public static native long MessageHandler_new(long chan_handler_arg, long route_handler_arg);
+ // uint64_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
+ public static native long SocketDescriptor_clone_ptr(long arg);
// struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
public static native long SocketDescriptor_clone(long orig);
// void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
public static native void PeerHandleError_set_no_connection_possible(long this_ptr, boolean val);
// MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(bool no_connection_possible_arg);
public static native long PeerHandleError_new(boolean no_connection_possible_arg);
+ // uint64_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
+ public static native long PeerHandleError_clone_ptr(long arg);
// struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
public static native long PeerHandleError_clone(long orig);
// void PeerManager_free(struct LDKPeerManager this_obj);
public static native void TxCreationKeys_set_broadcaster_delayed_payment_key(long this_ptr, byte[] val);
// MUST_USE_RES struct LDKTxCreationKeys TxCreationKeys_new(struct LDKPublicKey per_commitment_point_arg, struct LDKPublicKey revocation_key_arg, struct LDKPublicKey broadcaster_htlc_key_arg, struct LDKPublicKey countersignatory_htlc_key_arg, struct LDKPublicKey broadcaster_delayed_payment_key_arg);
public static native long TxCreationKeys_new(byte[] per_commitment_point_arg, byte[] revocation_key_arg, byte[] broadcaster_htlc_key_arg, byte[] countersignatory_htlc_key_arg, byte[] broadcaster_delayed_payment_key_arg);
+ // uint64_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
+ public static native long TxCreationKeys_clone_ptr(long arg);
// struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
public static native long TxCreationKeys_clone(long orig);
// struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
public static native void ChannelPublicKeys_set_htlc_basepoint(long this_ptr, byte[] val);
// MUST_USE_RES struct LDKChannelPublicKeys ChannelPublicKeys_new(struct LDKPublicKey funding_pubkey_arg, struct LDKPublicKey revocation_basepoint_arg, struct LDKPublicKey payment_point_arg, struct LDKPublicKey delayed_payment_basepoint_arg, struct LDKPublicKey htlc_basepoint_arg);
public static native long ChannelPublicKeys_new(byte[] funding_pubkey_arg, byte[] revocation_basepoint_arg, byte[] payment_point_arg, byte[] delayed_payment_basepoint_arg, byte[] htlc_basepoint_arg);
+ // uint64_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
+ public static native long ChannelPublicKeys_clone_ptr(long arg);
// struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
public static native long ChannelPublicKeys_clone(long orig);
// struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
public static native void HTLCOutputInCommitment_set_transaction_output_index(long this_ptr, long val);
// MUST_USE_RES struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_new(bool offered_arg, uint64_t amount_msat_arg, uint32_t cltv_expiry_arg, struct LDKThirtyTwoBytes payment_hash_arg, struct LDKCOption_u32Z transaction_output_index_arg);
public static native long HTLCOutputInCommitment_new(boolean offered_arg, long amount_msat_arg, int cltv_expiry_arg, byte[] payment_hash_arg, long transaction_output_index_arg);
+ // uint64_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
+ public static native long HTLCOutputInCommitment_clone_ptr(long arg);
// struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
public static native long HTLCOutputInCommitment_clone(long orig);
// struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
public static native void ChannelTransactionParameters_set_funding_outpoint(long this_ptr, long val);
// MUST_USE_RES struct LDKChannelTransactionParameters ChannelTransactionParameters_new(struct LDKChannelPublicKeys holder_pubkeys_arg, uint16_t holder_selected_contest_delay_arg, bool is_outbound_from_holder_arg, struct LDKCounterpartyChannelTransactionParameters counterparty_parameters_arg, struct LDKOutPoint funding_outpoint_arg);
public static native long ChannelTransactionParameters_new(long holder_pubkeys_arg, short holder_selected_contest_delay_arg, boolean is_outbound_from_holder_arg, long counterparty_parameters_arg, long funding_outpoint_arg);
+ // uint64_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
+ public static native long ChannelTransactionParameters_clone_ptr(long arg);
// struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
public static native long ChannelTransactionParameters_clone(long orig);
// void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
public static native void CounterpartyChannelTransactionParameters_set_selected_contest_delay(long this_ptr, short val);
// MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
public static native long CounterpartyChannelTransactionParameters_new(long pubkeys_arg, short selected_contest_delay_arg);
+ // uint64_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
+ public static native long CounterpartyChannelTransactionParameters_clone_ptr(long arg);
// struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
public static native long CounterpartyChannelTransactionParameters_clone(long orig);
// MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
public static native void HolderCommitmentTransaction_set_counterparty_sig(long this_ptr, byte[] val);
// void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
public static native void HolderCommitmentTransaction_set_counterparty_htlc_sigs(long this_ptr, byte[][] val);
+ // uint64_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
+ public static native long HolderCommitmentTransaction_clone_ptr(long arg);
// struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
public static native long HolderCommitmentTransaction_clone(long orig);
// struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
public static native void BuiltCommitmentTransaction_set_txid(long this_ptr, byte[] val);
// MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
public static native long BuiltCommitmentTransaction_new(byte[] transaction_arg, byte[] txid_arg);
+ // uint64_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
+ public static native long BuiltCommitmentTransaction_clone_ptr(long arg);
// struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
public static native long BuiltCommitmentTransaction_clone(long orig);
// struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
public static native byte[] BuiltCommitmentTransaction_sign(long this_arg, byte[] funding_key, byte[] funding_redeemscript, long channel_value_satoshis);
// void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
public static native void ClosingTransaction_free(long this_obj);
+ // uint64_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
+ public static native long ClosingTransaction_clone_ptr(long arg);
// struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
public static native long ClosingTransaction_clone(long orig);
// uint64_t ClosingTransaction_hash(const struct LDKClosingTransaction *NONNULL_PTR o);
public static native byte[] TrustedClosingTransaction_sign(long this_arg, byte[] funding_key, byte[] funding_redeemscript, long channel_value_satoshis);
// void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
public static native void CommitmentTransaction_free(long this_obj);
+ // uint64_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
+ public static native long CommitmentTransaction_clone_ptr(long arg);
// struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
public static native long CommitmentTransaction_clone(long orig);
// struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
public static native boolean ChannelFeatures_eq(long a, long b);
// bool InvoiceFeatures_eq(const struct LDKInvoiceFeatures *NONNULL_PTR a, const struct LDKInvoiceFeatures *NONNULL_PTR b);
public static native boolean InvoiceFeatures_eq(long a, long b);
+ // uint64_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
+ public static native long InitFeatures_clone_ptr(long arg);
// struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
public static native long InitFeatures_clone(long orig);
+ // uint64_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
+ public static native long NodeFeatures_clone_ptr(long arg);
// struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
public static native long NodeFeatures_clone(long orig);
+ // uint64_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
+ public static native long ChannelFeatures_clone_ptr(long arg);
// struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
public static native long ChannelFeatures_clone(long orig);
+ // uint64_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg);
+ public static native long InvoiceFeatures_clone_ptr(long arg);
// struct LDKInvoiceFeatures InvoiceFeatures_clone(const struct LDKInvoiceFeatures *NONNULL_PTR orig);
public static native long InvoiceFeatures_clone(long orig);
// void InitFeatures_free(struct LDKInitFeatures this_obj);
public static native long InvoiceFeatures_read(byte[] ser);
// void ShutdownScript_free(struct LDKShutdownScript this_obj);
public static native void ShutdownScript_free(long this_obj);
+ // uint64_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
+ public static native long ShutdownScript_clone_ptr(long arg);
// struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
public static native long ShutdownScript_clone(long orig);
// void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
public static native void InvalidShutdownScript_set_script(long this_ptr, byte[] val);
// MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
public static native long InvalidShutdownScript_new(byte[] script_arg);
+ // uint64_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
+ public static native long InvalidShutdownScript_clone_ptr(long arg);
// struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
public static native long InvalidShutdownScript_clone(long orig);
// struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
public static native boolean ShutdownScript_is_compatible(long this_arg, long features);
// void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
public static native void CustomMessageReader_free(long this_ptr);
+ // uint64_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
+ public static native long Type_clone_ptr(long arg);
// struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
public static native long Type_clone(long orig);
// void Type_free(struct LDKType this_ptr);
public static native byte[] LockableScore_write(long obj);
// void NodeId_free(struct LDKNodeId this_obj);
public static native void NodeId_free(long this_obj);
+ // uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
+ public static native long NodeId_clone_ptr(long arg);
// struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
public static native long NodeId_clone(long orig);
// MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
public static native long NodeId_read(byte[] ser);
// void NetworkGraph_free(struct LDKNetworkGraph this_obj);
public static native void NetworkGraph_free(long this_obj);
+ // uint64_t NetworkGraph_clone_ptr(LDKNetworkGraph *NONNULL_PTR arg);
+ public static native long NetworkGraph_clone_ptr(long arg);
// struct LDKNetworkGraph NetworkGraph_clone(const struct LDKNetworkGraph *NONNULL_PTR orig);
public static native long NetworkGraph_clone(long orig);
// void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
public static native void ReadOnlyNetworkGraph_free(long this_obj);
// void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
public static native void NetworkUpdate_free(long this_ptr);
+ // uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
+ public static native long NetworkUpdate_clone_ptr(long arg);
// struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
public static native long NetworkUpdate_clone(long orig);
// struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
public static native long NetworkUpdate_node_failure(byte[] node_id, boolean is_permanent);
// struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
public static native byte[] NetworkUpdate_write(long obj);
+ // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
+ public static native long NetworkUpdate_read(byte[] ser);
// struct LDKEventHandler NetGraphMsgHandler_as_EventHandler(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
public static native long NetGraphMsgHandler_as_EventHandler(long this_arg);
// void NetGraphMsgHandler_free(struct LDKNetGraphMsgHandler this_obj);
public static native void DirectionalChannelInfo_set_last_update_message(long this_ptr, long val);
// MUST_USE_RES struct LDKDirectionalChannelInfo DirectionalChannelInfo_new(uint32_t last_update_arg, bool enabled_arg, uint16_t cltv_expiry_delta_arg, uint64_t htlc_minimum_msat_arg, struct LDKCOption_u64Z htlc_maximum_msat_arg, struct LDKRoutingFees fees_arg, struct LDKChannelUpdate last_update_message_arg);
public static native long DirectionalChannelInfo_new(int last_update_arg, boolean enabled_arg, short cltv_expiry_delta_arg, long htlc_minimum_msat_arg, long htlc_maximum_msat_arg, long fees_arg, long last_update_message_arg);
+ // uint64_t DirectionalChannelInfo_clone_ptr(LDKDirectionalChannelInfo *NONNULL_PTR arg);
+ public static native long DirectionalChannelInfo_clone_ptr(long arg);
// struct LDKDirectionalChannelInfo DirectionalChannelInfo_clone(const struct LDKDirectionalChannelInfo *NONNULL_PTR orig);
public static native long DirectionalChannelInfo_clone(long orig);
// struct LDKCVec_u8Z DirectionalChannelInfo_write(const struct LDKDirectionalChannelInfo *NONNULL_PTR obj);
public static native void ChannelInfo_set_announcement_message(long this_ptr, long val);
// MUST_USE_RES struct LDKChannelInfo ChannelInfo_new(struct LDKChannelFeatures features_arg, struct LDKNodeId node_one_arg, struct LDKDirectionalChannelInfo one_to_two_arg, struct LDKNodeId node_two_arg, struct LDKDirectionalChannelInfo two_to_one_arg, struct LDKCOption_u64Z capacity_sats_arg, struct LDKChannelAnnouncement announcement_message_arg);
public static native long ChannelInfo_new(long features_arg, long node_one_arg, long one_to_two_arg, long node_two_arg, long two_to_one_arg, long capacity_sats_arg, long announcement_message_arg);
+ // uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
+ public static native long ChannelInfo_clone_ptr(long arg);
// struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
public static native long ChannelInfo_clone(long orig);
// struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
public static native long RoutingFees_new(int base_msat_arg, int proportional_millionths_arg);
// bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
public static native boolean RoutingFees_eq(long a, long b);
+ // uint64_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
+ public static native long RoutingFees_clone_ptr(long arg);
// struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
public static native long RoutingFees_clone(long orig);
// uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
public static native void NodeAnnouncementInfo_set_announcement_message(long this_ptr, long val);
// MUST_USE_RES struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_new(struct LDKNodeFeatures features_arg, uint32_t last_update_arg, struct LDKThreeBytes rgb_arg, struct LDKThirtyTwoBytes alias_arg, struct LDKCVec_NetAddressZ addresses_arg, struct LDKNodeAnnouncement announcement_message_arg);
public static native long NodeAnnouncementInfo_new(long features_arg, int last_update_arg, byte[] rgb_arg, byte[] alias_arg, long[] addresses_arg, long announcement_message_arg);
+ // uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
+ public static native long NodeAnnouncementInfo_clone_ptr(long arg);
// struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
public static native long NodeAnnouncementInfo_clone(long orig);
// struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
public static native void NodeInfo_set_announcement_info(long this_ptr, long val);
// MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKRoutingFees lowest_inbound_channel_fees_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
public static native long NodeInfo_new(long[] channels_arg, long lowest_inbound_channel_fees_arg, long announcement_info_arg);
+ // uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
+ public static native long NodeInfo_clone_ptr(long arg);
// struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
public static native long NodeInfo_clone(long orig);
// struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
public static native void RouteHop_set_cltv_expiry_delta(long this_ptr, int val);
// MUST_USE_RES struct LDKRouteHop RouteHop_new(struct LDKPublicKey pubkey_arg, struct LDKNodeFeatures node_features_arg, uint64_t short_channel_id_arg, struct LDKChannelFeatures channel_features_arg, uint64_t fee_msat_arg, uint32_t cltv_expiry_delta_arg);
public static native long RouteHop_new(byte[] pubkey_arg, long node_features_arg, long short_channel_id_arg, long channel_features_arg, long fee_msat_arg, int cltv_expiry_delta_arg);
+ // uint64_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
+ public static native long RouteHop_clone_ptr(long arg);
// struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
public static native long RouteHop_clone(long orig);
// uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
public static native void Route_set_payee(long this_ptr, long val);
// MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_CVec_RouteHopZZ paths_arg, struct LDKPayee payee_arg);
public static native long Route_new(long[][] paths_arg, long payee_arg);
+ // uint64_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
+ public static native long Route_clone_ptr(long arg);
// struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
public static native long Route_clone(long orig);
// uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
public static native void RouteParameters_set_final_cltv_expiry_delta(long this_ptr, int val);
// MUST_USE_RES struct LDKRouteParameters RouteParameters_new(struct LDKPayee payee_arg, uint64_t final_value_msat_arg, uint32_t final_cltv_expiry_delta_arg);
public static native long RouteParameters_new(long payee_arg, long final_value_msat_arg, int final_cltv_expiry_delta_arg);
+ // uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
+ public static native long RouteParameters_clone_ptr(long arg);
// struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
public static native long RouteParameters_clone(long orig);
// struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
public static native void Payee_set_expiry_time(long this_ptr, long val);
// MUST_USE_RES struct LDKPayee Payee_new(struct LDKPublicKey pubkey_arg, struct LDKInvoiceFeatures features_arg, struct LDKCVec_RouteHintZ route_hints_arg, struct LDKCOption_u64Z expiry_time_arg);
public static native long Payee_new(byte[] pubkey_arg, long features_arg, long[] route_hints_arg, long expiry_time_arg);
+ // uint64_t Payee_clone_ptr(LDKPayee *NONNULL_PTR arg);
+ public static native long Payee_clone_ptr(long arg);
// struct LDKPayee Payee_clone(const struct LDKPayee *NONNULL_PTR orig);
public static native long Payee_clone(long orig);
// uint64_t Payee_hash(const struct LDKPayee *NONNULL_PTR o);
public static native void RouteHint_set_a(long this_ptr, long[] val);
// MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
public static native long RouteHint_new(long[] a_arg);
+ // uint64_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
+ public static native long RouteHint_clone_ptr(long arg);
// struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
public static native long RouteHint_clone(long orig);
// uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
public static native void RouteHintHop_set_htlc_maximum_msat(long this_ptr, long val);
// MUST_USE_RES struct LDKRouteHintHop RouteHintHop_new(struct LDKPublicKey src_node_id_arg, uint64_t short_channel_id_arg, struct LDKRoutingFees fees_arg, uint16_t cltv_expiry_delta_arg, struct LDKCOption_u64Z htlc_minimum_msat_arg, struct LDKCOption_u64Z htlc_maximum_msat_arg);
public static native long RouteHintHop_new(byte[] src_node_id_arg, long short_channel_id_arg, long fees_arg, short cltv_expiry_delta_arg, long htlc_minimum_msat_arg, long htlc_maximum_msat_arg);
+ // uint64_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
+ public static native long RouteHintHop_clone_ptr(long arg);
// struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
public static native long RouteHintHop_clone(long orig);
// uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
public static native void Invoice_free(long this_obj);
// bool Invoice_eq(const struct LDKInvoice *NONNULL_PTR a, const struct LDKInvoice *NONNULL_PTR b);
public static native boolean Invoice_eq(long a, long b);
+ // uint64_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg);
+ public static native long Invoice_clone_ptr(long arg);
// struct LDKInvoice Invoice_clone(const struct LDKInvoice *NONNULL_PTR orig);
public static native long Invoice_clone(long orig);
// void SignedRawInvoice_free(struct LDKSignedRawInvoice this_obj);
public static native void SignedRawInvoice_free(long this_obj);
// bool SignedRawInvoice_eq(const struct LDKSignedRawInvoice *NONNULL_PTR a, const struct LDKSignedRawInvoice *NONNULL_PTR b);
public static native boolean SignedRawInvoice_eq(long a, long b);
+ // uint64_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg);
+ public static native long SignedRawInvoice_clone_ptr(long arg);
// struct LDKSignedRawInvoice SignedRawInvoice_clone(const struct LDKSignedRawInvoice *NONNULL_PTR orig);
public static native long SignedRawInvoice_clone(long orig);
// void RawInvoice_free(struct LDKRawInvoice this_obj);
public static native void RawInvoice_set_data(long this_ptr, long val);
// bool RawInvoice_eq(const struct LDKRawInvoice *NONNULL_PTR a, const struct LDKRawInvoice *NONNULL_PTR b);
public static native boolean RawInvoice_eq(long a, long b);
+ // uint64_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg);
+ public static native long RawInvoice_clone_ptr(long arg);
// struct LDKRawInvoice RawInvoice_clone(const struct LDKRawInvoice *NONNULL_PTR orig);
public static native long RawInvoice_clone(long orig);
// void RawDataPart_free(struct LDKRawDataPart this_obj);
public static native void RawDataPart_set_timestamp(long this_ptr, long val);
// bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
public static native boolean RawDataPart_eq(long a, long b);
+ // uint64_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg);
+ public static native long RawDataPart_clone_ptr(long arg);
// struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
public static native long RawDataPart_clone(long orig);
// void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
public static native void PositiveTimestamp_free(long this_obj);
// bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
public static native boolean PositiveTimestamp_eq(long a, long b);
+ // uint64_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg);
+ public static native long PositiveTimestamp_clone_ptr(long arg);
// struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
public static native long PositiveTimestamp_clone(long orig);
// enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
public static native boolean Currency_eq(long a, long b);
// void Sha256_free(struct LDKSha256 this_obj);
public static native void Sha256_free(long this_obj);
+ // uint64_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg);
+ public static native long Sha256_clone_ptr(long arg);
// struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
public static native long Sha256_clone(long orig);
// uint64_t Sha256_hash(const struct LDKSha256 *NONNULL_PTR o);
public static native boolean Sha256_eq(long a, long b);
// void Description_free(struct LDKDescription this_obj);
public static native void Description_free(long this_obj);
+ // uint64_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg);
+ public static native long Description_clone_ptr(long arg);
// struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
public static native long Description_clone(long orig);
// uint64_t Description_hash(const struct LDKDescription *NONNULL_PTR o);
public static native void PayeePubKey_set_a(long this_ptr, byte[] val);
// MUST_USE_RES struct LDKPayeePubKey PayeePubKey_new(struct LDKPublicKey a_arg);
public static native long PayeePubKey_new(byte[] a_arg);
+ // uint64_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg);
+ public static native long PayeePubKey_clone_ptr(long arg);
// struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
public static native long PayeePubKey_clone(long orig);
// uint64_t PayeePubKey_hash(const struct LDKPayeePubKey *NONNULL_PTR o);
public static native boolean PayeePubKey_eq(long a, long b);
// void ExpiryTime_free(struct LDKExpiryTime this_obj);
public static native void ExpiryTime_free(long this_obj);
+ // uint64_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg);
+ public static native long ExpiryTime_clone_ptr(long arg);
// struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
public static native long ExpiryTime_clone(long orig);
// uint64_t ExpiryTime_hash(const struct LDKExpiryTime *NONNULL_PTR o);
public static native void MinFinalCltvExpiry_set_a(long this_ptr, long val);
// MUST_USE_RES struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_new(uint64_t a_arg);
public static native long MinFinalCltvExpiry_new(long a_arg);
+ // uint64_t MinFinalCltvExpiry_clone_ptr(LDKMinFinalCltvExpiry *NONNULL_PTR arg);
+ public static native long MinFinalCltvExpiry_clone_ptr(long arg);
// struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_clone(const struct LDKMinFinalCltvExpiry *NONNULL_PTR orig);
public static native long MinFinalCltvExpiry_clone(long orig);
// uint64_t MinFinalCltvExpiry_hash(const struct LDKMinFinalCltvExpiry *NONNULL_PTR o);
public static native boolean MinFinalCltvExpiry_eq(long a, long b);
// void Fallback_free(struct LDKFallback this_ptr);
public static native void Fallback_free(long this_ptr);
+ // uint64_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg);
+ public static native long Fallback_clone_ptr(long arg);
// struct LDKFallback Fallback_clone(const struct LDKFallback *NONNULL_PTR orig);
public static native long Fallback_clone(long orig);
// struct LDKFallback Fallback_seg_wit_program(struct LDKu5 version, struct LDKCVec_u8Z program);
public static native boolean Fallback_eq(long a, long b);
// void InvoiceSignature_free(struct LDKInvoiceSignature this_obj);
public static native void InvoiceSignature_free(long this_obj);
+ // uint64_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg);
+ public static native long InvoiceSignature_clone_ptr(long arg);
// struct LDKInvoiceSignature InvoiceSignature_clone(const struct LDKInvoiceSignature *NONNULL_PTR orig);
public static native long InvoiceSignature_clone(long orig);
// bool InvoiceSignature_eq(const struct LDKInvoiceSignature *NONNULL_PTR a, const struct LDKInvoiceSignature *NONNULL_PTR b);
public static native boolean InvoiceSignature_eq(long a, long b);
// void PrivateRoute_free(struct LDKPrivateRoute this_obj);
public static native void PrivateRoute_free(long this_obj);
+ // uint64_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg);
+ public static native long PrivateRoute_clone_ptr(long arg);
// struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
public static native long PrivateRoute_clone(long orig);
// uint64_t PrivateRoute_hash(const struct LDKPrivateRoute *NONNULL_PTR o);
public static native String SemanticError_to_str(long o);
// void SignOrCreationError_free(struct LDKSignOrCreationError this_ptr);
public static native void SignOrCreationError_free(long this_ptr);
+ // uint64_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg);
+ public static native long SignOrCreationError_clone_ptr(long arg);
// struct LDKSignOrCreationError SignOrCreationError_clone(const struct LDKSignOrCreationError *NONNULL_PTR orig);
public static native long SignOrCreationError_clone(long orig);
// struct LDKSignOrCreationError SignOrCreationError_sign_error(void);
public static native void RetryAttempts_set_a(long this_ptr, long val);
// MUST_USE_RES struct LDKRetryAttempts RetryAttempts_new(uintptr_t a_arg);
public static native long RetryAttempts_new(long a_arg);
+ // uint64_t RetryAttempts_clone_ptr(LDKRetryAttempts *NONNULL_PTR arg);
+ public static native long RetryAttempts_clone_ptr(long arg);
// struct LDKRetryAttempts RetryAttempts_clone(const struct LDKRetryAttempts *NONNULL_PTR orig);
public static native long RetryAttempts_clone(long orig);
// bool RetryAttempts_eq(const struct LDKRetryAttempts *NONNULL_PTR a, const struct LDKRetryAttempts *NONNULL_PTR b);
public static native long RetryAttempts_hash(long o);
// void PaymentError_free(struct LDKPaymentError this_ptr);
public static native void PaymentError_free(long this_ptr);
+ // uint64_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg);
+ public static native long PaymentError_clone_ptr(long arg);
// struct LDKPaymentError PaymentError_clone(const struct LDKPaymentError *NONNULL_PTR orig);
public static native long PaymentError_clone(long orig);
// struct LDKPaymentError PaymentError_invoice(struct LDKStr a);
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * Indicates the API was wholly misused (see err for more). Cases where these can be returned
+ * are documented, but generally indicates some precondition of a function was violated.
+ */
public final static class APIMisuseError extends APIError {
/**
* A human-readable error message
this.err = obj.err;
}
}
+ /**
+ * Due to a high feerate, we were unable to complete the request.
+ * For example, this may be returned if the feerate implies we cannot open a channel at the
+ * requested value, but opening a larger channel would succeed.
+ */
public final static class FeeRateTooHigh extends APIError {
/**
* A human-readable error message
this.feerate = obj.feerate;
}
}
+ /**
+ * A malformed Route was provided (eg overflowed value, node id mismatch, overly-looped route,
+ * too-many-hops, etc).
+ */
public final static class RouteError extends APIError {
/**
* A human-readable error message
this.err = obj.err;
}
}
+ /**
+ * We were unable to complete the request as the Channel required to do so is unable to
+ * complete the request (or was not found). This can take many forms, including disconnected
+ * peer, channel at capacity, channel shutting down, etc.
+ */
public final static class ChannelUnavailable extends APIError {
/**
* A human-readable error message
this.err = obj.err;
}
}
+ /**
+ * An attempt to call watch/update_channel returned an Err (ie you did this!), causing the
+ * attempted action to fail.
+ */
public final static class MonitorUpdateFailed extends APIError {
private MonitorUpdateFailed(long ptr, bindings.LDKAPIError.MonitorUpdateFailed obj) {
super(null, ptr);
}
}
+ /**
+ * [`KeysInterface::get_shutdown_scriptpubkey`] returned a shutdown scriptpubkey incompatible
+ * with the channel counterparty as negotiated in [`InitFeatures`].
+ *
+ * Using a SegWit v0 script should resolve this issue. If you cannot, you won't be able to open
+ * a channel or cooperatively close one with this peer (and will have to force-close instead).
+ *
+ * [`KeysInterface::get_shutdown_scriptpubkey`]: crate::chain::keysinterface::KeysInterface::get_shutdown_scriptpubkey
+ * [`InitFeatures`]: crate::ln::features::InitFeatures
+ */
public final static class IncompatibleShutdownScript extends APIError {
/**
* The incompatible shutdown script.
this.script = script_hu_conv;
}
}
+ long clone_ptr() {
+ long ret = bindings.APIError_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the APIError
*/
* A temporary channel ID, until the funding outpoint is announced
*/
public void set_temporary_channel_id(byte[] val) {
- bindings.AcceptChannel_set_temporary_channel_id(this.ptr, val);
+ bindings.AcceptChannel_set_temporary_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* The sender's key controlling the funding transaction
*/
public void set_funding_pubkey(byte[] val) {
- bindings.AcceptChannel_set_funding_pubkey(this.ptr, val);
+ bindings.AcceptChannel_set_funding_pubkey(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* Used to derive a revocation key for transactions broadcast by counterparty
*/
public void set_revocation_basepoint(byte[] val) {
- bindings.AcceptChannel_set_revocation_basepoint(this.ptr, val);
+ bindings.AcceptChannel_set_revocation_basepoint(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* A payment key to sender for transactions broadcast by counterparty
*/
public void set_payment_point(byte[] val) {
- bindings.AcceptChannel_set_payment_point(this.ptr, val);
+ bindings.AcceptChannel_set_payment_point(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* Used to derive a payment key to sender for transactions broadcast by sender
*/
public void set_delayed_payment_basepoint(byte[] val) {
- bindings.AcceptChannel_set_delayed_payment_basepoint(this.ptr, val);
+ bindings.AcceptChannel_set_delayed_payment_basepoint(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
*/
public void set_htlc_basepoint(byte[] val) {
- bindings.AcceptChannel_set_htlc_basepoint(this.ptr, val);
+ bindings.AcceptChannel_set_htlc_basepoint(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* The first to-be-broadcast-by-sender transaction's per commitment point
*/
public void set_first_per_commitment_point(byte[] val) {
- bindings.AcceptChannel_set_first_per_commitment_point(this.ptr, val);
+ bindings.AcceptChannel_set_first_per_commitment_point(this.ptr, InternalUtils.check_arr_len(val, 33));
+ }
+
+ long clone_ptr() {
+ long ret = bindings.AcceptChannel_clone_ptr(this.ptr);
+ return ret;
}
/**
impl_holder.held = new Access(new bindings.LDKAccess() {
@Override public long get_utxo(byte[] genesis_hash, long short_channel_id) {
Result_TxOutAccessErrorZ ret = arg.get_utxo(genesis_hash, short_channel_id);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
});
* [`short_channel_id`]: https://github.com/lightningnetwork/lightning-rfc/blob/master/07-routing-gossip.md#definition-of-short_channel_id
*/
public Result_TxOutAccessErrorZ get_utxo(byte[] genesis_hash, long short_channel_id) {
- long ret = bindings.Access_get_utxo(this.ptr, genesis_hash, short_channel_id);
+ long ret = bindings.Access_get_utxo(this.ptr, InternalUtils.check_arr_len(genesis_hash, 32), short_channel_id);
if (ret >= 0 && ret <= 4096) { return null; }
Result_TxOutAccessErrorZ ret_hu_conv = Result_TxOutAccessErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
* The channel ID
*/
public void set_channel_id(byte[] val) {
- bindings.AnnouncementSignatures_set_channel_id(this.ptr, val);
+ bindings.AnnouncementSignatures_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* A signature by the node key
*/
public void set_node_signature(byte[] val) {
- bindings.AnnouncementSignatures_set_node_signature(this.ptr, val);
+ bindings.AnnouncementSignatures_set_node_signature(this.ptr, InternalUtils.check_arr_len(val, 64));
}
/**
* A signature by the funding key
*/
public void set_bitcoin_signature(byte[] val) {
- bindings.AnnouncementSignatures_set_bitcoin_signature(this.ptr, val);
+ bindings.AnnouncementSignatures_set_bitcoin_signature(this.ptr, InternalUtils.check_arr_len(val, 64));
}
/**
* Constructs a new AnnouncementSignatures given each field
*/
public static AnnouncementSignatures of(byte[] channel_id_arg, long short_channel_id_arg, byte[] node_signature_arg, byte[] bitcoin_signature_arg) {
- long ret = bindings.AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
+ long ret = bindings.AnnouncementSignatures_new(InternalUtils.check_arr_len(channel_id_arg, 32), short_channel_id_arg, InternalUtils.check_arr_len(node_signature_arg, 64), InternalUtils.check_arr_len(bitcoin_signature_arg, 64));
if (ret >= 0 && ret <= 4096) { return null; }
AnnouncementSignatures ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new AnnouncementSignatures(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.AnnouncementSignatures_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the AnnouncementSignatures
*/
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * The channel is not yet closed (or the commitment or closing transaction has not yet
+ * appeared in a block). The given balance is claimable (less on-chain fees) if the channel is
+ * force-closed now.
+ */
public final static class ClaimableOnChannelClose extends Balance {
/**
* The amount available to claim, in satoshis, excluding the on-chain fees which will be
this.claimable_amount_satoshis = obj.claimable_amount_satoshis;
}
}
+ /**
+ * The channel has been closed, and the given balance is ours but awaiting confirmations until
+ * we consider it spendable.
+ */
public final static class ClaimableAwaitingConfirmations extends Balance {
/**
* The amount available to claim, in satoshis, possibly excluding the on-chain fees which
this.confirmation_height = obj.confirmation_height;
}
}
+ /**
+ * The channel has been closed, and the given balance should be ours but awaiting spending
+ * transaction confirmation. If the spending transaction does not confirm in time, it is
+ * possible our counterparty can take the funds by broadcasting an HTLC timeout on-chain.
+ *
+ * Once the spending transaction confirms, before it has reached enough confirmations to be
+ * considered safe from chain reorganizations, the balance will instead be provided via
+ * [`Balance::ClaimableAwaitingConfirmations`].
+ */
public final static class ContentiousClaimable extends Balance {
/**
* The amount available to claim, in satoshis, excluding the on-chain fees which will be
this.timeout_height = obj.timeout_height;
}
}
+ /**
+ * HTLCs which we sent to our counterparty which are claimable after a timeout (less on-chain
+ * fees) if the counterparty does not know the preimage for the HTLCs. These are somewhat
+ * likely to be claimed by our counterparty before we do.
+ */
public final static class MaybeClaimableHTLCAwaitingTimeout extends Balance {
/**
* The amount available to claim, in satoshis, excluding the on-chain fees which will be
this.claimable_height = obj.claimable_height;
}
}
+ long clone_ptr() {
+ long ret = bindings.Balance_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the Balance
*/
final bindings.LDKBaseSign bindings_instance;
BaseSign(Object _dummy, long ptr) { super(ptr); bindings_instance = null; }
private BaseSign(bindings.LDKBaseSign arg, ChannelPublicKeys pubkeys) {
- super(bindings.LDKBaseSign_new(arg, pubkeys == null ? 0 : pubkeys.ptr & ~1));
+ super(bindings.LDKBaseSign_new(arg, pubkeys == null ? 0 : pubkeys.clone_ptr()));
this.ptrs_to.add(arg);
this.bindings_instance = arg;
}
impl_holder.held = new BaseSign(new bindings.LDKBaseSign() {
@Override public byte[] get_per_commitment_point(long idx) {
byte[] ret = arg.get_per_commitment_point(idx);
- return ret;
+ byte[] result = InternalUtils.check_arr_len(ret, 33);
+ return result;
}
@Override public byte[] release_commitment_secret(long idx) {
byte[] ret = arg.release_commitment_secret(idx);
- return ret;
+ byte[] result = InternalUtils.check_arr_len(ret, 32);
+ return result;
}
@Override public long validate_holder_commitment(long holder_tx) {
HolderCommitmentTransaction holder_tx_hu_conv = null; if (holder_tx < 0 || holder_tx > 4096) { holder_tx_hu_conv = new HolderCommitmentTransaction(null, holder_tx); }
Result_NoneNoneZ ret = arg.validate_holder_commitment(holder_tx_hu_conv);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
@Override public byte[] channel_keys_id() {
byte[] ret = arg.channel_keys_id();
- return ret;
+ byte[] result = InternalUtils.check_arr_len(ret, 32);
+ return result;
}
@Override public long sign_counterparty_commitment(long commitment_tx) {
CommitmentTransaction commitment_tx_hu_conv = null; if (commitment_tx < 0 || commitment_tx > 4096) { commitment_tx_hu_conv = new CommitmentTransaction(null, commitment_tx); }
Result_C2Tuple_SignatureCVec_SignatureZZNoneZ ret = arg.sign_counterparty_commitment(commitment_tx_hu_conv);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
@Override public long validate_counterparty_revocation(long idx, byte[] secret) {
Result_NoneNoneZ ret = arg.validate_counterparty_revocation(idx, secret);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
@Override public long sign_holder_commitment_and_htlcs(long commitment_tx) {
HolderCommitmentTransaction commitment_tx_hu_conv = null; if (commitment_tx < 0 || commitment_tx > 4096) { commitment_tx_hu_conv = new HolderCommitmentTransaction(null, commitment_tx); }
Result_C2Tuple_SignatureCVec_SignatureZZNoneZ ret = arg.sign_holder_commitment_and_htlcs(commitment_tx_hu_conv);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
@Override public long sign_justice_revoked_output(byte[] justice_tx, long input, long amount, byte[] per_commitment_key) {
Result_SignatureNoneZ ret = arg.sign_justice_revoked_output(justice_tx, input, amount, per_commitment_key);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
@Override public long sign_justice_revoked_htlc(byte[] justice_tx, long input, long amount, byte[] per_commitment_key, long htlc) {
HTLCOutputInCommitment htlc_hu_conv = null; if (htlc < 0 || htlc > 4096) { htlc_hu_conv = new HTLCOutputInCommitment(null, htlc); }
Result_SignatureNoneZ ret = arg.sign_justice_revoked_htlc(justice_tx, input, amount, per_commitment_key, htlc_hu_conv);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
@Override public long sign_counterparty_htlc_transaction(byte[] htlc_tx, long input, long amount, byte[] per_commitment_point, long htlc) {
HTLCOutputInCommitment htlc_hu_conv = null; if (htlc < 0 || htlc > 4096) { htlc_hu_conv = new HTLCOutputInCommitment(null, htlc); }
Result_SignatureNoneZ ret = arg.sign_counterparty_htlc_transaction(htlc_tx, input, amount, per_commitment_point, htlc_hu_conv);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
@Override public long sign_closing_transaction(long closing_tx) {
ClosingTransaction closing_tx_hu_conv = null; if (closing_tx < 0 || closing_tx > 4096) { closing_tx_hu_conv = new ClosingTransaction(null, closing_tx); }
Result_SignatureNoneZ ret = arg.sign_closing_transaction(closing_tx_hu_conv);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
@Override public long sign_channel_announcement(long msg) {
UnsignedChannelAnnouncement msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new UnsignedChannelAnnouncement(null, msg); }
Result_SignatureNoneZ ret = arg.sign_channel_announcement(msg_hu_conv);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
@Override public void ready_channel(long channel_parameters) {
* forward and it is safe to sign the next counterparty commitment.
*/
public Result_NoneNoneZ validate_counterparty_revocation(long idx, byte[] secret) {
- long ret = bindings.BaseSign_validate_counterparty_revocation(this.ptr, idx, secret);
+ long ret = bindings.BaseSign_validate_counterparty_revocation(this.ptr, idx, InternalUtils.check_arr_len(secret, 32));
if (ret >= 0 && ret <= 4096) { return null; }
Result_NoneNoneZ ret_hu_conv = Result_NoneNoneZ.constr_from_ptr(ret);
return ret_hu_conv;
* so).
*/
public Result_SignatureNoneZ sign_justice_revoked_output(byte[] justice_tx, long input, long amount, byte[] per_commitment_key) {
- long ret = bindings.BaseSign_sign_justice_revoked_output(this.ptr, justice_tx, input, amount, per_commitment_key);
+ long ret = bindings.BaseSign_sign_justice_revoked_output(this.ptr, justice_tx, input, amount, InternalUtils.check_arr_len(per_commitment_key, 32));
if (ret >= 0 && ret <= 4096) { return null; }
Result_SignatureNoneZ ret_hu_conv = Result_SignatureNoneZ.constr_from_ptr(ret);
return ret_hu_conv;
* (which is committed to in the BIP 143 signatures).
*/
public Result_SignatureNoneZ sign_justice_revoked_htlc(byte[] justice_tx, long input, long amount, byte[] per_commitment_key, HTLCOutputInCommitment htlc) {
- long ret = bindings.BaseSign_sign_justice_revoked_htlc(this.ptr, justice_tx, input, amount, per_commitment_key, htlc == null ? 0 : htlc.ptr & ~1);
+ long ret = bindings.BaseSign_sign_justice_revoked_htlc(this.ptr, justice_tx, input, amount, InternalUtils.check_arr_len(per_commitment_key, 32), htlc == null ? 0 : htlc.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
Result_SignatureNoneZ ret_hu_conv = Result_SignatureNoneZ.constr_from_ptr(ret);
this.ptrs_to.add(htlc);
* BIP 143 signature.
*/
public Result_SignatureNoneZ sign_counterparty_htlc_transaction(byte[] htlc_tx, long input, long amount, byte[] per_commitment_point, HTLCOutputInCommitment htlc) {
- long ret = bindings.BaseSign_sign_counterparty_htlc_transaction(this.ptr, htlc_tx, input, amount, per_commitment_point, htlc == null ? 0 : htlc.ptr & ~1);
+ long ret = bindings.BaseSign_sign_counterparty_htlc_transaction(this.ptr, htlc_tx, input, amount, InternalUtils.check_arr_len(per_commitment_point, 33), htlc == null ? 0 : htlc.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
Result_SignatureNoneZ ret_hu_conv = Result_SignatureNoneZ.constr_from_ptr(ret);
this.ptrs_to.add(htlc);
if (ptr != 0) { bindings.BestBlock_free(ptr); }
}
+ long clone_ptr() {
+ long ret = bindings.BestBlock_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the BestBlock
*/
* Returns a `BestBlock` as identified by the given block hash and height.
*/
public static BestBlock of(byte[] block_hash, int height) {
- long ret = bindings.BestBlock_new(block_hash, height);
+ long ret = bindings.BestBlock_new(InternalUtils.check_arr_len(block_hash, 32), height);
if (ret >= 0 && ret <= 4096) { return null; }
BestBlock ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new BestBlock(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* multiple times.
*/
public void set_txid(byte[] val) {
- bindings.BuiltCommitmentTransaction_set_txid(this.ptr, val);
+ bindings.BuiltCommitmentTransaction_set_txid(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* Constructs a new BuiltCommitmentTransaction given each field
*/
public static BuiltCommitmentTransaction of(byte[] transaction_arg, byte[] txid_arg) {
- long ret = bindings.BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
+ long ret = bindings.BuiltCommitmentTransaction_new(transaction_arg, InternalUtils.check_arr_len(txid_arg, 32));
if (ret >= 0 && ret <= 4096) { return null; }
BuiltCommitmentTransaction ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new BuiltCommitmentTransaction(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.BuiltCommitmentTransaction_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the BuiltCommitmentTransaction
*/
* because we are about to broadcast a holder transaction.
*/
public byte[] sign(byte[] funding_key, byte[] funding_redeemscript, long channel_value_satoshis) {
- byte[] ret = bindings.BuiltCommitmentTransaction_sign(this.ptr, funding_key, funding_redeemscript, channel_value_satoshis);
+ byte[] ret = bindings.BuiltCommitmentTransaction_sign(this.ptr, InternalUtils.check_arr_len(funding_key, 32), funding_redeemscript, channel_value_satoshis);
return ret;
}
if (ret >= 0 && ret <= 4096) { return null; }
ChainMonitor ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new ChainMonitor(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
+ ret_hu_conv.ptrs_to.add(chain_source);
ret_hu_conv.ptrs_to.add(broadcaster);
ret_hu_conv.ptrs_to.add(logger);
ret_hu_conv.ptrs_to.add(feeest);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.ChainParameters_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ChainParameters
*/
* Authentication of the announcement by the first public node
*/
public void set_node_signature_1(byte[] val) {
- bindings.ChannelAnnouncement_set_node_signature_1(this.ptr, val);
+ bindings.ChannelAnnouncement_set_node_signature_1(this.ptr, InternalUtils.check_arr_len(val, 64));
}
/**
* Authentication of the announcement by the second public node
*/
public void set_node_signature_2(byte[] val) {
- bindings.ChannelAnnouncement_set_node_signature_2(this.ptr, val);
+ bindings.ChannelAnnouncement_set_node_signature_2(this.ptr, InternalUtils.check_arr_len(val, 64));
}
/**
* Proof of funding UTXO ownership by the first public node
*/
public void set_bitcoin_signature_1(byte[] val) {
- bindings.ChannelAnnouncement_set_bitcoin_signature_1(this.ptr, val);
+ bindings.ChannelAnnouncement_set_bitcoin_signature_1(this.ptr, InternalUtils.check_arr_len(val, 64));
}
/**
* Proof of funding UTXO ownership by the second public node
*/
public void set_bitcoin_signature_2(byte[] val) {
- bindings.ChannelAnnouncement_set_bitcoin_signature_2(this.ptr, val);
+ bindings.ChannelAnnouncement_set_bitcoin_signature_2(this.ptr, InternalUtils.check_arr_len(val, 64));
}
/**
* Constructs a new ChannelAnnouncement given each field
*/
public static ChannelAnnouncement of(byte[] node_signature_1_arg, byte[] node_signature_2_arg, byte[] bitcoin_signature_1_arg, byte[] bitcoin_signature_2_arg, UnsignedChannelAnnouncement contents_arg) {
- long ret = bindings.ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg == null ? 0 : contents_arg.ptr & ~1);
+ long ret = bindings.ChannelAnnouncement_new(InternalUtils.check_arr_len(node_signature_1_arg, 64), InternalUtils.check_arr_len(node_signature_2_arg, 64), InternalUtils.check_arr_len(bitcoin_signature_1_arg, 64), InternalUtils.check_arr_len(bitcoin_signature_2_arg, 64), contents_arg == null ? 0 : contents_arg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
ChannelAnnouncement ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new ChannelAnnouncement(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.ChannelAnnouncement_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ChannelAnnouncement
*/
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.ChannelConfig_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ChannelConfig
*/
* The node_id of our counterparty
*/
public void set_node_id(byte[] val) {
- bindings.ChannelCounterparty_set_node_id(this.ptr, val);
+ bindings.ChannelCounterparty_set_node_id(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* Constructs a new ChannelCounterparty given each field
*/
public static ChannelCounterparty of(byte[] node_id_arg, InitFeatures features_arg, long unspendable_punishment_reserve_arg, CounterpartyForwardingInfo forwarding_info_arg) {
- long ret = bindings.ChannelCounterparty_new(node_id_arg, features_arg == null ? 0 : features_arg.ptr & ~1, unspendable_punishment_reserve_arg, forwarding_info_arg == null ? 0 : forwarding_info_arg.ptr & ~1);
+ long ret = bindings.ChannelCounterparty_new(InternalUtils.check_arr_len(node_id_arg, 33), features_arg == null ? 0 : features_arg.ptr & ~1, unspendable_punishment_reserve_arg, forwarding_info_arg == null ? 0 : forwarding_info_arg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
ChannelCounterparty ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new ChannelCounterparty(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.ChannelCounterparty_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ChannelCounterparty
*/
* lifetime of the channel.
*/
public void set_channel_id(byte[] val) {
- bindings.ChannelDetails_set_channel_id(this.ptr, val);
+ bindings.ChannelDetails_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* Constructs a new ChannelDetails given each field
*/
public static ChannelDetails of(byte[] channel_id_arg, ChannelCounterparty counterparty_arg, OutPoint funding_txo_arg, Option_u64Z short_channel_id_arg, long channel_value_satoshis_arg, Option_u64Z unspendable_punishment_reserve_arg, long user_channel_id_arg, long outbound_capacity_msat_arg, long inbound_capacity_msat_arg, Option_u32Z confirmations_required_arg, Option_u16Z force_close_spend_delay_arg, boolean is_outbound_arg, boolean is_funding_locked_arg, boolean is_usable_arg, boolean is_public_arg) {
- long ret = bindings.ChannelDetails_new(channel_id_arg, counterparty_arg == null ? 0 : counterparty_arg.ptr & ~1, funding_txo_arg == null ? 0 : funding_txo_arg.ptr & ~1, short_channel_id_arg.ptr, channel_value_satoshis_arg, unspendable_punishment_reserve_arg.ptr, user_channel_id_arg, outbound_capacity_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg.ptr, force_close_spend_delay_arg.ptr, is_outbound_arg, is_funding_locked_arg, is_usable_arg, is_public_arg);
+ long ret = bindings.ChannelDetails_new(InternalUtils.check_arr_len(channel_id_arg, 32), counterparty_arg == null ? 0 : counterparty_arg.ptr & ~1, funding_txo_arg == null ? 0 : funding_txo_arg.ptr & ~1, short_channel_id_arg.ptr, channel_value_satoshis_arg, unspendable_punishment_reserve_arg.ptr, user_channel_id_arg, outbound_capacity_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg.ptr, force_close_spend_delay_arg.ptr, is_outbound_arg, is_funding_locked_arg, is_usable_arg, is_public_arg);
if (ret >= 0 && ret <= 4096) { return null; }
ChannelDetails ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new ChannelDetails(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.ChannelDetails_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ChannelDetails
*/
return ret;
}
+ long clone_ptr() {
+ long ret = bindings.ChannelFeatures_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ChannelFeatures
*/
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.ChannelHandshakeConfig_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ChannelHandshakeConfig
*/
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.ChannelHandshakeLimits_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ChannelHandshakeLimits
*/
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.ChannelInfo_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ChannelInfo
*/
* Note that override_config (or a relevant inner pointer) may be NULL or all-0s to represent None
*/
public Result__u832APIErrorZ create_channel(byte[] their_network_key, long channel_value_satoshis, long push_msat, long user_channel_id, @Nullable UserConfig override_config) {
- long ret = bindings.ChannelManager_create_channel(this.ptr, their_network_key, channel_value_satoshis, push_msat, user_channel_id, override_config == null ? 0 : override_config.ptr & ~1);
+ long ret = bindings.ChannelManager_create_channel(this.ptr, InternalUtils.check_arr_len(their_network_key, 33), channel_value_satoshis, push_msat, user_channel_id, override_config == null ? 0 : override_config.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
Result__u832APIErrorZ ret_hu_conv = Result__u832APIErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
* [`Normal`]: crate::chain::chaininterface::ConfirmationTarget::Normal
*/
public Result_NoneAPIErrorZ close_channel(byte[] channel_id) {
- long ret = bindings.ChannelManager_close_channel(this.ptr, channel_id);
+ long ret = bindings.ChannelManager_close_channel(this.ptr, InternalUtils.check_arr_len(channel_id, 32));
if (ret >= 0 && ret <= 4096) { return null; }
Result_NoneAPIErrorZ ret_hu_conv = Result_NoneAPIErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
* [`Normal`]: crate::chain::chaininterface::ConfirmationTarget::Normal
*/
public Result_NoneAPIErrorZ close_channel_with_target_feerate(byte[] channel_id, int target_feerate_sats_per_1000_weight) {
- long ret = bindings.ChannelManager_close_channel_with_target_feerate(this.ptr, channel_id, target_feerate_sats_per_1000_weight);
+ long ret = bindings.ChannelManager_close_channel_with_target_feerate(this.ptr, InternalUtils.check_arr_len(channel_id, 32), target_feerate_sats_per_1000_weight);
if (ret >= 0 && ret <= 4096) { return null; }
Result_NoneAPIErrorZ ret_hu_conv = Result_NoneAPIErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
* the chain and rejecting new HTLCs on the given channel. Fails if channel_id is unknown to the manager.
*/
public Result_NoneAPIErrorZ force_close_channel(byte[] channel_id) {
- long ret = bindings.ChannelManager_force_close_channel(this.ptr, channel_id);
+ long ret = bindings.ChannelManager_force_close_channel(this.ptr, InternalUtils.check_arr_len(channel_id, 32));
if (ret >= 0 && ret <= 4096) { return null; }
Result_NoneAPIErrorZ ret_hu_conv = Result_NoneAPIErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
* Note that payment_secret (or a relevant inner pointer) may be NULL or all-0s to represent None
*/
public Result_PaymentIdPaymentSendFailureZ send_payment(Route route, byte[] payment_hash, @Nullable byte[] payment_secret) {
- long ret = bindings.ChannelManager_send_payment(this.ptr, route == null ? 0 : route.ptr & ~1, payment_hash, payment_secret);
+ long ret = bindings.ChannelManager_send_payment(this.ptr, route == null ? 0 : route.ptr & ~1, InternalUtils.check_arr_len(payment_hash, 32), InternalUtils.check_arr_len(payment_secret, 32));
if (ret >= 0 && ret <= 4096) { return null; }
Result_PaymentIdPaymentSendFailureZ ret_hu_conv = Result_PaymentIdPaymentSendFailureZ.constr_from_ptr(ret);
this.ptrs_to.add(route);
* [`send_payment`]: [`ChannelManager::send_payment`]
*/
public Result_NonePaymentSendFailureZ retry_payment(Route route, byte[] payment_id) {
- long ret = bindings.ChannelManager_retry_payment(this.ptr, route == null ? 0 : route.ptr & ~1, payment_id);
+ long ret = bindings.ChannelManager_retry_payment(this.ptr, route == null ? 0 : route.ptr & ~1, InternalUtils.check_arr_len(payment_id, 32));
if (ret >= 0 && ret <= 4096) { return null; }
Result_NonePaymentSendFailureZ ret_hu_conv = Result_NonePaymentSendFailureZ.constr_from_ptr(ret);
this.ptrs_to.add(route);
* Note that payment_preimage (or a relevant inner pointer) may be NULL or all-0s to represent None
*/
public Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ send_spontaneous_payment(Route route, @Nullable byte[] payment_preimage) {
- long ret = bindings.ChannelManager_send_spontaneous_payment(this.ptr, route == null ? 0 : route.ptr & ~1, payment_preimage);
+ long ret = bindings.ChannelManager_send_spontaneous_payment(this.ptr, route == null ? 0 : route.ptr & ~1, InternalUtils.check_arr_len(payment_preimage, 32));
if (ret >= 0 && ret <= 4096) { return null; }
Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ ret_hu_conv = Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ.constr_from_ptr(ret);
this.ptrs_to.add(route);
* [`Event::FundingGenerationReady`]: crate::util::events::Event::FundingGenerationReady
*/
public Result_NoneAPIErrorZ funding_transaction_generated(byte[] temporary_channel_id, byte[] funding_transaction) {
- long ret = bindings.ChannelManager_funding_transaction_generated(this.ptr, temporary_channel_id, funding_transaction);
+ long ret = bindings.ChannelManager_funding_transaction_generated(this.ptr, InternalUtils.check_arr_len(temporary_channel_id, 32), funding_transaction);
if (ret >= 0 && ret <= 4096) { return null; }
Result_NoneAPIErrorZ ret_hu_conv = Result_NoneAPIErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
* [`get_and_clear_pending_msg_events`]: MessageSendEventsProvider::get_and_clear_pending_msg_events
*/
public void broadcast_node_announcement(byte[] rgb, byte[] alias, NetAddress[] addresses) {
- bindings.ChannelManager_broadcast_node_announcement(this.ptr, rgb, alias, addresses != null ? Arrays.stream(addresses).mapToLong(addresses_conv_12 -> addresses_conv_12.ptr).toArray() : null);
+ bindings.ChannelManager_broadcast_node_announcement(this.ptr, InternalUtils.check_arr_len(rgb, 3), InternalUtils.check_arr_len(alias, 32), addresses != null ? Arrays.stream(addresses).mapToLong(addresses_conv_12 -> addresses_conv_12.ptr).toArray() : null);
}
/**
* HTLC backwards has been started.
*/
public boolean fail_htlc_backwards(byte[] payment_hash) {
- boolean ret = bindings.ChannelManager_fail_htlc_backwards(this.ptr, payment_hash);
+ boolean ret = bindings.ChannelManager_fail_htlc_backwards(this.ptr, InternalUtils.check_arr_len(payment_hash, 32));
return ret;
}
* [`create_inbound_payment_for_hash`]: Self::create_inbound_payment_for_hash
*/
public boolean claim_funds(byte[] payment_preimage) {
- boolean ret = bindings.ChannelManager_claim_funds(this.ptr, payment_preimage);
+ boolean ret = bindings.ChannelManager_claim_funds(this.ptr, InternalUtils.check_arr_len(payment_preimage, 32));
return ret;
}
* [`PaymentPurpose::InvoicePayment::user_payment_id`]: events::PaymentPurpose::InvoicePayment::user_payment_id
*/
public Result_PaymentSecretAPIErrorZ create_inbound_payment_for_hash(byte[] payment_hash, Option_u64Z min_value_msat, int invoice_expiry_delta_secs, long user_payment_id) {
- long ret = bindings.ChannelManager_create_inbound_payment_for_hash(this.ptr, payment_hash, min_value_msat.ptr, invoice_expiry_delta_secs, user_payment_id);
+ long ret = bindings.ChannelManager_create_inbound_payment_for_hash(this.ptr, InternalUtils.check_arr_len(payment_hash, 32), min_value_msat.ptr, invoice_expiry_delta_secs, user_payment_id);
if (ret >= 0 && ret <= 4096) { return null; }
Result_PaymentSecretAPIErrorZ ret_hu_conv = Result_PaymentSecretAPIErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
@Override public long persist_manager(long channel_manager) {
ChannelManager channel_manager_hu_conv = null; if (channel_manager < 0 || channel_manager > 4096) { channel_manager_hu_conv = new ChannelManager(null, channel_manager); }
Result_NoneErrorZ ret = arg.persist_manager(channel_manager_hu_conv);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
});
* Handle an incoming open_channel message from the given peer.
*/
public void handle_open_channel(byte[] their_node_id, InitFeatures their_features, OpenChannel msg) {
- bindings.ChannelMessageHandler_handle_open_channel(this.ptr, their_node_id, their_features == null ? 0 : their_features.ptr & ~1, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_open_channel(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), their_features == null ? 0 : their_features.ptr & ~1, msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
* Handle an incoming accept_channel message from the given peer.
*/
public void handle_accept_channel(byte[] their_node_id, InitFeatures their_features, AcceptChannel msg) {
- bindings.ChannelMessageHandler_handle_accept_channel(this.ptr, their_node_id, their_features == null ? 0 : their_features.ptr & ~1, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_accept_channel(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), their_features == null ? 0 : their_features.ptr & ~1, msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
* Handle an incoming funding_created message from the given peer.
*/
public void handle_funding_created(byte[] their_node_id, FundingCreated msg) {
- bindings.ChannelMessageHandler_handle_funding_created(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_funding_created(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
* Handle an incoming funding_signed message from the given peer.
*/
public void handle_funding_signed(byte[] their_node_id, FundingSigned msg) {
- bindings.ChannelMessageHandler_handle_funding_signed(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_funding_signed(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
* Handle an incoming funding_locked message from the given peer.
*/
public void handle_funding_locked(byte[] their_node_id, FundingLocked msg) {
- bindings.ChannelMessageHandler_handle_funding_locked(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_funding_locked(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
* Handle an incoming shutdown message from the given peer.
*/
public void handle_shutdown(byte[] their_node_id, InitFeatures their_features, Shutdown msg) {
- bindings.ChannelMessageHandler_handle_shutdown(this.ptr, their_node_id, their_features == null ? 0 : their_features.ptr & ~1, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_shutdown(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), their_features == null ? 0 : their_features.ptr & ~1, msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(their_features);
this.ptrs_to.add(msg);
}
* Handle an incoming closing_signed message from the given peer.
*/
public void handle_closing_signed(byte[] their_node_id, ClosingSigned msg) {
- bindings.ChannelMessageHandler_handle_closing_signed(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_closing_signed(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
* Handle an incoming update_add_htlc message from the given peer.
*/
public void handle_update_add_htlc(byte[] their_node_id, UpdateAddHTLC msg) {
- bindings.ChannelMessageHandler_handle_update_add_htlc(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_update_add_htlc(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
* Handle an incoming update_fulfill_htlc message from the given peer.
*/
public void handle_update_fulfill_htlc(byte[] their_node_id, UpdateFulfillHTLC msg) {
- bindings.ChannelMessageHandler_handle_update_fulfill_htlc(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_update_fulfill_htlc(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
* Handle an incoming update_fail_htlc message from the given peer.
*/
public void handle_update_fail_htlc(byte[] their_node_id, UpdateFailHTLC msg) {
- bindings.ChannelMessageHandler_handle_update_fail_htlc(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_update_fail_htlc(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
* Handle an incoming update_fail_malformed_htlc message from the given peer.
*/
public void handle_update_fail_malformed_htlc(byte[] their_node_id, UpdateFailMalformedHTLC msg) {
- bindings.ChannelMessageHandler_handle_update_fail_malformed_htlc(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_update_fail_malformed_htlc(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
* Handle an incoming commitment_signed message from the given peer.
*/
public void handle_commitment_signed(byte[] their_node_id, CommitmentSigned msg) {
- bindings.ChannelMessageHandler_handle_commitment_signed(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_commitment_signed(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
* Handle an incoming revoke_and_ack message from the given peer.
*/
public void handle_revoke_and_ack(byte[] their_node_id, RevokeAndACK msg) {
- bindings.ChannelMessageHandler_handle_revoke_and_ack(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_revoke_and_ack(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
* Handle an incoming update_fee message from the given peer.
*/
public void handle_update_fee(byte[] their_node_id, UpdateFee msg) {
- bindings.ChannelMessageHandler_handle_update_fee(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_update_fee(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
* Handle an incoming announcement_signatures message from the given peer.
*/
public void handle_announcement_signatures(byte[] their_node_id, AnnouncementSignatures msg) {
- bindings.ChannelMessageHandler_handle_announcement_signatures(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_announcement_signatures(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
* and any outstanding channels should be failed.
*/
public void peer_disconnected(byte[] their_node_id, boolean no_connection_possible) {
- bindings.ChannelMessageHandler_peer_disconnected(this.ptr, their_node_id, no_connection_possible);
+ bindings.ChannelMessageHandler_peer_disconnected(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), no_connection_possible);
}
/**
* Handle a peer reconnecting, possibly generating channel_reestablish message(s).
*/
public void peer_connected(byte[] their_node_id, Init msg) {
- bindings.ChannelMessageHandler_peer_connected(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_peer_connected(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
* Handle an incoming channel_reestablish message from the given peer.
*/
public void handle_channel_reestablish(byte[] their_node_id, ChannelReestablish msg) {
- bindings.ChannelMessageHandler_handle_channel_reestablish(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_channel_reestablish(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
* Handle an incoming channel update from the given peer.
*/
public void handle_channel_update(byte[] their_node_id, ChannelUpdate msg) {
- bindings.ChannelMessageHandler_handle_channel_update(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_channel_update(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
* Handle an incoming error message from the given peer.
*/
public void handle_error(byte[] their_node_id, ErrorMessage msg) {
- bindings.ChannelMessageHandler_handle_error(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_error(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
if (ptr != 0) { bindings.ChannelMonitor_free(ptr); }
}
+ long clone_ptr() {
+ long ret = bindings.ChannelMonitor_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ChannelMonitor
*/
* [`get_outputs_to_watch`]: #method.get_outputs_to_watch
*/
public TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[] block_connected(byte[] header, TwoTuple_usizeTransactionZ[] txdata, int height, BroadcasterInterface broadcaster, FeeEstimator fee_estimator, Logger logger) {
- long[] ret = bindings.ChannelMonitor_block_connected(this.ptr, header, txdata != null ? Arrays.stream(txdata).mapToLong(txdata_conv_28 -> txdata_conv_28 != null ? txdata_conv_28.ptr : 0).toArray() : null, height, broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr);
+ long[] ret = bindings.ChannelMonitor_block_connected(this.ptr, InternalUtils.check_arr_len(header, 80), txdata != null ? Arrays.stream(txdata).mapToLong(txdata_conv_28 -> txdata_conv_28 != null ? txdata_conv_28.ptr : 0).toArray() : null, height, broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr);
TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[] ret_conv_39_arr = new TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[ret.length];
for (int n = 0; n < ret.length; n++) {
long ret_conv_39 = ret[n];
* appropriately.
*/
public void block_disconnected(byte[] header, int height, BroadcasterInterface broadcaster, FeeEstimator fee_estimator, Logger logger) {
- bindings.ChannelMonitor_block_disconnected(this.ptr, header, height, broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr);
+ bindings.ChannelMonitor_block_disconnected(this.ptr, InternalUtils.check_arr_len(header, 80), height, broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr);
this.ptrs_to.add(broadcaster);
this.ptrs_to.add(fee_estimator);
this.ptrs_to.add(logger);
* [`block_connected`]: Self::block_connected
*/
public TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[] transactions_confirmed(byte[] header, TwoTuple_usizeTransactionZ[] txdata, int height, BroadcasterInterface broadcaster, FeeEstimator fee_estimator, Logger logger) {
- long[] ret = bindings.ChannelMonitor_transactions_confirmed(this.ptr, header, txdata != null ? Arrays.stream(txdata).mapToLong(txdata_conv_28 -> txdata_conv_28 != null ? txdata_conv_28.ptr : 0).toArray() : null, height, broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr);
+ long[] ret = bindings.ChannelMonitor_transactions_confirmed(this.ptr, InternalUtils.check_arr_len(header, 80), txdata != null ? Arrays.stream(txdata).mapToLong(txdata_conv_28 -> txdata_conv_28 != null ? txdata_conv_28.ptr : 0).toArray() : null, height, broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr);
TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[] ret_conv_39_arr = new TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[ret.length];
for (int n = 0; n < ret.length; n++) {
long ret_conv_39 = ret[n];
* [`block_disconnected`]: Self::block_disconnected
*/
public void transaction_unconfirmed(byte[] txid, BroadcasterInterface broadcaster, FeeEstimator fee_estimator, Logger logger) {
- bindings.ChannelMonitor_transaction_unconfirmed(this.ptr, txid, broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr);
+ bindings.ChannelMonitor_transaction_unconfirmed(this.ptr, InternalUtils.check_arr_len(txid, 32), broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr);
this.ptrs_to.add(broadcaster);
this.ptrs_to.add(fee_estimator);
this.ptrs_to.add(logger);
* [`block_connected`]: Self::block_connected
*/
public TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[] best_block_updated(byte[] header, int height, BroadcasterInterface broadcaster, FeeEstimator fee_estimator, Logger logger) {
- long[] ret = bindings.ChannelMonitor_best_block_updated(this.ptr, header, height, broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr);
+ long[] ret = bindings.ChannelMonitor_best_block_updated(this.ptr, InternalUtils.check_arr_len(header, 80), height, broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr);
TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[] ret_conv_39_arr = new TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[ret.length];
for (int n = 0; n < ret.length; n++) {
long ret_conv_39 = ret[n];
bindings.ChannelMonitorUpdate_set_update_id(this.ptr, val);
}
+ long clone_ptr() {
+ long ret = bindings.ChannelMonitorUpdate_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ChannelMonitorUpdate
*/
* on-chain channel lock-in 2-of-2 multisig output.
*/
public void set_funding_pubkey(byte[] val) {
- bindings.ChannelPublicKeys_set_funding_pubkey(this.ptr, val);
+ bindings.ChannelPublicKeys_set_funding_pubkey(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* states.
*/
public void set_revocation_basepoint(byte[] val) {
- bindings.ChannelPublicKeys_set_revocation_basepoint(this.ptr, val);
+ bindings.ChannelPublicKeys_set_revocation_basepoint(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* static across every commitment transaction.
*/
public void set_payment_point(byte[] val) {
- bindings.ChannelPublicKeys_set_payment_point(this.ptr, val);
+ bindings.ChannelPublicKeys_set_payment_point(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* after some delay (or can be claimed via the revocation path).
*/
public void set_delayed_payment_basepoint(byte[] val) {
- bindings.ChannelPublicKeys_set_delayed_payment_basepoint(this.ptr, val);
+ bindings.ChannelPublicKeys_set_delayed_payment_basepoint(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* which is used to encumber HTLC-in-flight outputs.
*/
public void set_htlc_basepoint(byte[] val) {
- bindings.ChannelPublicKeys_set_htlc_basepoint(this.ptr, val);
+ bindings.ChannelPublicKeys_set_htlc_basepoint(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* Constructs a new ChannelPublicKeys given each field
*/
public static ChannelPublicKeys of(byte[] funding_pubkey_arg, byte[] revocation_basepoint_arg, byte[] payment_point_arg, byte[] delayed_payment_basepoint_arg, byte[] htlc_basepoint_arg) {
- long ret = bindings.ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
+ long ret = bindings.ChannelPublicKeys_new(InternalUtils.check_arr_len(funding_pubkey_arg, 33), InternalUtils.check_arr_len(revocation_basepoint_arg, 33), InternalUtils.check_arr_len(payment_point_arg, 33), InternalUtils.check_arr_len(delayed_payment_basepoint_arg, 33), InternalUtils.check_arr_len(htlc_basepoint_arg, 33));
if (ret >= 0 && ret <= 4096) { return null; }
ChannelPublicKeys ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new ChannelPublicKeys(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.ChannelPublicKeys_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ChannelPublicKeys
*/
* The channel ID
*/
public void set_channel_id(byte[] val) {
- bindings.ChannelReestablish_set_channel_id(this.ptr, val);
+ bindings.ChannelReestablish_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
bindings.ChannelReestablish_set_next_remote_commitment_number(this.ptr, val);
}
+ long clone_ptr() {
+ long ret = bindings.ChannelReestablish_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ChannelReestablish
*/
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.ChannelTransactionParameters_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ChannelTransactionParameters
*/
* A signature of the channel update
*/
public void set_signature(byte[] val) {
- bindings.ChannelUpdate_set_signature(this.ptr, val);
+ bindings.ChannelUpdate_set_signature(this.ptr, InternalUtils.check_arr_len(val, 64));
}
/**
* Constructs a new ChannelUpdate given each field
*/
public static ChannelUpdate of(byte[] signature_arg, UnsignedChannelUpdate contents_arg) {
- long ret = bindings.ChannelUpdate_new(signature_arg, contents_arg == null ? 0 : contents_arg.ptr & ~1);
+ long ret = bindings.ChannelUpdate_new(InternalUtils.check_arr_len(signature_arg, 64), contents_arg == null ? 0 : contents_arg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
ChannelUpdate ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new ChannelUpdate(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.ChannelUpdate_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ChannelUpdate
*/
* The channel ID
*/
public void set_channel_id(byte[] val) {
- bindings.ClosingSigned_set_channel_id(this.ptr, val);
+ bindings.ClosingSigned_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* A signature on the closing transaction
*/
public void set_signature(byte[] val) {
- bindings.ClosingSigned_set_signature(this.ptr, val);
+ bindings.ClosingSigned_set_signature(this.ptr, InternalUtils.check_arr_len(val, 64));
}
/**
* Constructs a new ClosingSigned given each field
*/
public static ClosingSigned of(byte[] channel_id_arg, long fee_satoshis_arg, byte[] signature_arg, ClosingSignedFeeRange fee_range_arg) {
- long ret = bindings.ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg == null ? 0 : fee_range_arg.ptr & ~1);
+ long ret = bindings.ClosingSigned_new(InternalUtils.check_arr_len(channel_id_arg, 32), fee_satoshis_arg, InternalUtils.check_arr_len(signature_arg, 64), fee_range_arg == null ? 0 : fee_range_arg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
ClosingSigned ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new ClosingSigned(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.ClosingSigned_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ClosingSigned
*/
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.ClosingSignedFeeRange_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ClosingSignedFeeRange
*/
if (ptr != 0) { bindings.ClosingTransaction_free(ptr); }
}
+ long clone_ptr() {
+ long ret = bindings.ClosingTransaction_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ClosingTransaction
*/
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * Closure generated from receiving a peer error message.
+ *
+ * Our counterparty may have broadcasted their latest commitment state, and we have
+ * as well.
+ */
public final static class CounterpartyForceClosed extends ClosureReason {
/**
* The error which the peer sent us.
this.peer_msg = obj.peer_msg;
}
}
+ /**
+ * Closure generated from [`ChannelManager::force_close_channel`], called by the user.
+ *
+ * [`ChannelManager::force_close_channel`]: crate::ln::channelmanager::ChannelManager::force_close_channel.
+ */
public final static class HolderForceClosed extends ClosureReason {
private HolderForceClosed(long ptr, bindings.LDKClosureReason.HolderForceClosed obj) {
super(null, ptr);
}
}
+ /**
+ * The channel was closed after negotiating a cooperative close and we've now broadcasted
+ * the cooperative close transaction. Note the shutdown may have been initiated by us.
+ */
public final static class CooperativeClosure extends ClosureReason {
private CooperativeClosure(long ptr, bindings.LDKClosureReason.CooperativeClosure obj) {
super(null, ptr);
}
}
+ /**
+ * A commitment transaction was confirmed on chain, closing the channel. Most likely this
+ * commitment transaction came from our counterparty, but it may also have come from
+ * a copy of our own `ChannelMonitor`.
+ */
public final static class CommitmentTxConfirmed extends ClosureReason {
private CommitmentTxConfirmed(long ptr, bindings.LDKClosureReason.CommitmentTxConfirmed obj) {
super(null, ptr);
}
}
+ /**
+ * Closure generated from processing an event, likely a HTLC forward/relay/reception.
+ */
public final static class ProcessingError extends ClosureReason {
/**
* A developer-readable error message which we generated.
this.err = obj.err;
}
}
+ /**
+ * The `PeerManager` informed us that we've disconnected from the peer. We close channels
+ * if the `PeerManager` informed us that it is unlikely we'll be able to connect to the
+ * peer again in the future or if the peer disconnected before we finished negotiating
+ * the channel open. The first case may be caused by incompatible features which our
+ * counterparty, or we, require.
+ */
public final static class DisconnectedPeer extends ClosureReason {
private DisconnectedPeer(long ptr, bindings.LDKClosureReason.DisconnectedPeer obj) {
super(null, ptr);
}
}
+ /**
+ * Closure generated from `ChannelManager::read` if the ChannelMonitor is newer than
+ * the ChannelManager deserialized.
+ */
public final static class OutdatedChannelManager extends ClosureReason {
private OutdatedChannelManager(long ptr, bindings.LDKClosureReason.OutdatedChannelManager obj) {
super(null, ptr);
}
}
+ long clone_ptr() {
+ long ret = bindings.ClosureReason_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ClosureReason
*/
* The channel ID
*/
public void set_channel_id(byte[] val) {
- bindings.CommitmentSigned_set_channel_id(this.ptr, val);
+ bindings.CommitmentSigned_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* A signature on the commitment transaction
*/
public void set_signature(byte[] val) {
- bindings.CommitmentSigned_set_signature(this.ptr, val);
+ bindings.CommitmentSigned_set_signature(this.ptr, InternalUtils.check_arr_len(val, 64));
}
/**
* Signatures on the HTLC transactions
*/
public void set_htlc_signatures(byte[][] val) {
- bindings.CommitmentSigned_set_htlc_signatures(this.ptr, val);
+ bindings.CommitmentSigned_set_htlc_signatures(this.ptr, val != null ? Arrays.stream(val).map(val_conv_8 -> InternalUtils.check_arr_len(val_conv_8, 64)).toArray(byte[][]::new) : null);
}
/**
* Constructs a new CommitmentSigned given each field
*/
public static CommitmentSigned of(byte[] channel_id_arg, byte[] signature_arg, byte[][] htlc_signatures_arg) {
- long ret = bindings.CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
+ long ret = bindings.CommitmentSigned_new(InternalUtils.check_arr_len(channel_id_arg, 32), InternalUtils.check_arr_len(signature_arg, 64), htlc_signatures_arg != null ? Arrays.stream(htlc_signatures_arg).map(htlc_signatures_arg_conv_8 -> InternalUtils.check_arr_len(htlc_signatures_arg_conv_8, 64)).toArray(byte[][]::new) : null);
if (ret >= 0 && ret <= 4096) { return null; }
CommitmentSigned ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new CommitmentSigned(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.CommitmentSigned_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the CommitmentSigned
*/
if (ptr != 0) { bindings.CommitmentTransaction_free(ptr); }
}
+ long clone_ptr() {
+ long ret = bindings.CommitmentTransaction_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the CommitmentTransaction
*/
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.CommitmentUpdate_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the CommitmentUpdate
*/
}
@Override public byte[][] get_relevant_txids() {
byte[][] ret = arg.get_relevant_txids();
- return ret;
+ byte[][] result = ret != null ? Arrays.stream(ret).map(ret_conv_8 -> InternalUtils.check_arr_len(ret_conv_8, 32)).toArray(byte[][]::new) : null;
+ return result;
}
});
return impl_holder.held;
* [`best_block_updated`]: Self::best_block_updated
*/
public void transactions_confirmed(byte[] header, TwoTuple_usizeTransactionZ[] txdata, int height) {
- bindings.Confirm_transactions_confirmed(this.ptr, header, txdata != null ? Arrays.stream(txdata).mapToLong(txdata_conv_28 -> txdata_conv_28 != null ? txdata_conv_28.ptr : 0).toArray() : null, height);
+ bindings.Confirm_transactions_confirmed(this.ptr, InternalUtils.check_arr_len(header, 80), txdata != null ? Arrays.stream(txdata).mapToLong(txdata_conv_28 -> txdata_conv_28 != null ? txdata_conv_28.ptr : 0).toArray() : null, height);
}
/**
* [`transactions_confirmed`]: Self::transactions_confirmed
*/
public void transaction_unconfirmed(byte[] txid) {
- bindings.Confirm_transaction_unconfirmed(this.ptr, txid);
+ bindings.Confirm_transaction_unconfirmed(this.ptr, InternalUtils.check_arr_len(txid, 32));
}
/**
* if they become available at the same time.
*/
public void best_block_updated(byte[] header, int height) {
- bindings.Confirm_best_block_updated(this.ptr, header, height);
+ bindings.Confirm_best_block_updated(this.ptr, InternalUtils.check_arr_len(header, 80), height);
}
/**
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.CounterpartyChannelTransactionParameters_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the CounterpartyChannelTransactionParameters
*/
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.CounterpartyForwardingInfo_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the CounterpartyForwardingInfo
*/
Type ret_hu_conv = new Type(null, msg);
ret_hu_conv.ptrs_to.add(this);
Result_NoneLightningErrorZ ret = arg.handle_custom_message(ret_hu_conv, sender_node_id);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
@Override public long[] get_and_clear_pending_msg() {
TwoTuple_PublicKeyTypeZ[] ret = arg.get_and_clear_pending_msg();
- long[] result = ret != null ? Arrays.stream(ret).mapToLong(ret_conv_25 -> ret_conv_25 != null ? ret_conv_25.ptr : 0).toArray() : null;
+ long[] result = ret != null ? Arrays.stream(ret).mapToLong(ret_conv_25 -> ret_conv_25 == null ? 0 : ret_conv_25.clone_ptr()).toArray() : null;
return result;
}
}, CustomMessageReader.new_impl(CustomMessageReader_impl).bindings_instance);
* Can return a `MessageHandlingError` if the message could not be handled.
*/
public Result_NoneLightningErrorZ handle_custom_message(Type msg, byte[] sender_node_id) {
- long ret = bindings.CustomMessageHandler_handle_custom_message(this.ptr, msg == null ? 0 : msg.ptr, sender_node_id);
+ long ret = bindings.CustomMessageHandler_handle_custom_message(this.ptr, msg == null ? 0 : msg.ptr, InternalUtils.check_arr_len(sender_node_id, 33));
if (ret >= 0 && ret <= 4096) { return null; }
Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
this.ptrs_to.add(msg);
impl_holder.held = new CustomMessageReader(new bindings.LDKCustomMessageReader() {
@Override public long read(short message_type, byte[] buffer) {
Result_COption_TypeZDecodeErrorZ ret = arg.read(message_type, buffer);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
});
* belonging to the recipient
*/
public void set_your_last_per_commitment_secret(byte[] val) {
- bindings.DataLossProtect_set_your_last_per_commitment_secret(this.ptr, val);
+ bindings.DataLossProtect_set_your_last_per_commitment_secret(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* The sender's per-commitment point for their current commitment transaction
*/
public void set_my_current_per_commitment_point(byte[] val) {
- bindings.DataLossProtect_set_my_current_per_commitment_point(this.ptr, val);
+ bindings.DataLossProtect_set_my_current_per_commitment_point(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* Constructs a new DataLossProtect given each field
*/
public static DataLossProtect of(byte[] your_last_per_commitment_secret_arg, byte[] my_current_per_commitment_point_arg) {
- long ret = bindings.DataLossProtect_new(your_last_per_commitment_secret_arg, my_current_per_commitment_point_arg);
+ long ret = bindings.DataLossProtect_new(InternalUtils.check_arr_len(your_last_per_commitment_secret_arg, 32), InternalUtils.check_arr_len(my_current_per_commitment_point_arg, 33));
if (ret >= 0 && ret <= 4096) { return null; }
DataLossProtect ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new DataLossProtect(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.DataLossProtect_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the DataLossProtect
*/
if (ptr != 0) { bindings.DecodeError_free(ptr); }
}
+ long clone_ptr() {
+ long ret = bindings.DecodeError_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the DecodeError
*/
* Per commitment point to derive delayed_payment_key by key holder
*/
public void set_per_commitment_point(byte[] val) {
- bindings.DelayedPaymentOutputDescriptor_set_per_commitment_point(this.ptr, val);
+ bindings.DelayedPaymentOutputDescriptor_set_per_commitment_point(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* derive the witnessScript for this output.
*/
public void set_revocation_pubkey(byte[] val) {
- bindings.DelayedPaymentOutputDescriptor_set_revocation_pubkey(this.ptr, val);
+ bindings.DelayedPaymentOutputDescriptor_set_revocation_pubkey(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* the channel to spend the output.
*/
public void set_channel_keys_id(byte[] val) {
- bindings.DelayedPaymentOutputDescriptor_set_channel_keys_id(this.ptr, val);
+ bindings.DelayedPaymentOutputDescriptor_set_channel_keys_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* Constructs a new DelayedPaymentOutputDescriptor given each field
*/
public static DelayedPaymentOutputDescriptor of(OutPoint outpoint_arg, byte[] per_commitment_point_arg, short to_self_delay_arg, TxOut output_arg, byte[] revocation_pubkey_arg, byte[] channel_keys_id_arg, long channel_value_satoshis_arg) {
- long ret = bindings.DelayedPaymentOutputDescriptor_new(outpoint_arg == null ? 0 : outpoint_arg.ptr & ~1, per_commitment_point_arg, to_self_delay_arg, output_arg.ptr, revocation_pubkey_arg, channel_keys_id_arg, channel_value_satoshis_arg);
+ long ret = bindings.DelayedPaymentOutputDescriptor_new(outpoint_arg == null ? 0 : outpoint_arg.ptr & ~1, InternalUtils.check_arr_len(per_commitment_point_arg, 33), to_self_delay_arg, output_arg.ptr, InternalUtils.check_arr_len(revocation_pubkey_arg, 33), InternalUtils.check_arr_len(channel_keys_id_arg, 32), channel_value_satoshis_arg);
if (ret >= 0 && ret <= 4096) { return null; }
DelayedPaymentOutputDescriptor ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new DelayedPaymentOutputDescriptor(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.DelayedPaymentOutputDescriptor_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the DelayedPaymentOutputDescriptor
*/
if (ptr != 0) { bindings.Description_free(ptr); }
}
+ long clone_ptr() {
+ long ret = bindings.Description_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the Description
*/
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.DirectionalChannelInfo_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the DirectionalChannelInfo
*/
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * The peer took some action which made us think they were useless. Disconnect them.
+ */
public final static class DisconnectPeer extends ErrorAction {
/**
* An error message which we should make an effort to send before we disconnect.
this.msg = msg_hu_conv;
}
}
+ /**
+ * The peer did something harmless that we weren't able to process, just log and ignore
+ */
public final static class IgnoreError extends ErrorAction {
private IgnoreError(long ptr, bindings.LDKErrorAction.IgnoreError obj) {
super(null, ptr);
}
}
+ /**
+ * The peer did something harmless that we weren't able to meaningfully process.
+ * If the error is logged, log it at the given level.
+ */
public final static class IgnoreAndLog extends ErrorAction {
public final Level ignore_and_log;
private IgnoreAndLog(long ptr, bindings.LDKErrorAction.IgnoreAndLog obj) {
this.ignore_and_log = obj.ignore_and_log;
}
}
+ /**
+ * The peer did something incorrect. Tell them.
+ */
public final static class SendErrorMessage extends ErrorAction {
/**
* The message to send.
this.msg = msg_hu_conv;
}
}
+ long clone_ptr() {
+ long ret = bindings.ErrorAction_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ErrorAction
*/
* The channel ID involved in the error
*/
public void set_channel_id(byte[] val) {
- bindings.ErrorMessage_set_channel_id(this.ptr, val);
+ bindings.ErrorMessage_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* Constructs a new ErrorMessage given each field
*/
public static ErrorMessage of(byte[] channel_id_arg, java.lang.String data_arg) {
- long ret = bindings.ErrorMessage_new(channel_id_arg, data_arg);
+ long ret = bindings.ErrorMessage_new(InternalUtils.check_arr_len(channel_id_arg, 32), data_arg);
if (ret >= 0 && ret <= 4096) { return null; }
ErrorMessage ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new ErrorMessage(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.ErrorMessage_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ErrorMessage
*/
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * Used to indicate that the client should generate a funding transaction with the given
+ * parameters and then call ChannelManager::funding_transaction_generated.
+ * Generated in ChannelManager message handling.
+ * Note that *all inputs* in the funding transaction must spend SegWit outputs or your
+ * counterparty can steal your funds!
+ */
public final static class FundingGenerationReady extends Event {
/**
* The random channel_id we picked which you'll need to pass into
this.user_channel_id = obj.user_channel_id;
}
}
+ /**
+ * Indicates we've received money! Just gotta dig out that payment preimage and feed it to
+ * [`ChannelManager::claim_funds`] to get it....
+ * Note that if the preimage is not known, you should call
+ * [`ChannelManager::fail_htlc_backwards`] to free up resources for this HTLC and avoid
+ * network congestion.
+ * If you fail to call either [`ChannelManager::claim_funds`] or
+ * [`ChannelManager::fail_htlc_backwards`] within the HTLC's timeout, the HTLC will be
+ * automatically failed.
+ *
+ * [`ChannelManager::claim_funds`]: crate::ln::channelmanager::ChannelManager::claim_funds
+ * [`ChannelManager::fail_htlc_backwards`]: crate::ln::channelmanager::ChannelManager::fail_htlc_backwards
+ */
public final static class PaymentReceived extends Event {
/**
* The hash for which the preimage should be handed to the ChannelManager.
this.purpose = purpose_hu_conv;
}
}
+ /**
+ * Indicates an outbound payment we made succeeded (i.e. it made it all the way to its target
+ * and we got back the payment preimage for it).
+ *
+ * Note for MPP payments: in rare cases, this event may be preceded by a `PaymentPathFailed`
+ * event. In this situation, you SHOULD treat this payment as having succeeded.
+ */
public final static class PaymentSent extends Event {
/**
* The id returned by [`ChannelManager::send_payment`] and used with
this.fee_paid_msat = fee_paid_msat_hu_conv;
}
}
+ /**
+ * Indicates an outbound payment we made failed. Probably some intermediary node dropped
+ * something. You may wish to retry with a different route.
+ */
public final static class PaymentPathFailed extends Event {
/**
* The id returned by [`ChannelManager::send_payment`] and used with
this.retry = retry_hu_conv;
}
}
+ /**
+ * Used to indicate that ChannelManager::process_pending_htlc_forwards should be called at a
+ * time in the future.
+ */
public final static class PendingHTLCsForwardable extends Event {
/**
* The minimum amount of time that should be waited prior to calling
this.time_forwardable = obj.time_forwardable;
}
}
+ /**
+ * Used to indicate that an output which you should know how to spend was confirmed on chain
+ * and is now spendable.
+ * Such an output will *not* ever be spent by rust-lightning, and are not at risk of your
+ * counterparty spending them due to some kind of timeout. Thus, you need to store them
+ * somewhere and spend them when you create on-chain transactions.
+ */
public final static class SpendableOutputs extends Event {
/**
* The outputs which you should store as spendable by you.
this.outputs = outputs_conv_27_arr;
}
}
+ /**
+ * This event is generated when a payment has been successfully forwarded through us and a
+ * forwarding fee earned.
+ */
public final static class PaymentForwarded extends Event {
/**
* The fee, in milli-satoshis, which was earned as a result of the payment.
this.claim_from_onchain_tx = obj.claim_from_onchain_tx;
}
}
+ /**
+ * Used to indicate that a channel with the given `channel_id` is in the process of closure.
+ */
public final static class ChannelClosed extends Event {
/**
* The channel_id of the channel which has been closed. Note that on-chain transactions
this.reason = reason_hu_conv;
}
}
+ /**
+ * Used to indicate to the user that they can abandon the funding transaction and recycle the
+ * inputs for another purpose.
+ */
public final static class DiscardFunding extends Event {
/**
* The channel_id of the channel which has been closed.
this.transaction = obj.transaction;
}
}
+ long clone_ptr() {
+ long ret = bindings.Event_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the Event
*/
* Utility method to constructs a new FundingGenerationReady-variant Event
*/
public static Event funding_generation_ready(byte[] temporary_channel_id, long channel_value_satoshis, byte[] output_script, long user_channel_id) {
- long ret = bindings.Event_funding_generation_ready(temporary_channel_id, channel_value_satoshis, output_script, user_channel_id);
+ long ret = bindings.Event_funding_generation_ready(InternalUtils.check_arr_len(temporary_channel_id, 32), channel_value_satoshis, output_script, user_channel_id);
if (ret >= 0 && ret <= 4096) { return null; }
Event ret_hu_conv = Event.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new PaymentReceived-variant Event
*/
public static Event payment_received(byte[] payment_hash, long amt, PaymentPurpose purpose) {
- long ret = bindings.Event_payment_received(payment_hash, amt, purpose.ptr);
+ long ret = bindings.Event_payment_received(InternalUtils.check_arr_len(payment_hash, 32), amt, purpose.ptr);
if (ret >= 0 && ret <= 4096) { return null; }
Event ret_hu_conv = Event.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new PaymentSent-variant Event
*/
public static Event payment_sent(byte[] payment_id, byte[] payment_preimage, byte[] payment_hash, Option_u64Z fee_paid_msat) {
- long ret = bindings.Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat.ptr);
+ long ret = bindings.Event_payment_sent(InternalUtils.check_arr_len(payment_id, 32), InternalUtils.check_arr_len(payment_preimage, 32), InternalUtils.check_arr_len(payment_hash, 32), fee_paid_msat.ptr);
if (ret >= 0 && ret <= 4096) { return null; }
Event ret_hu_conv = Event.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new PaymentPathFailed-variant Event
*/
public static Event payment_path_failed(byte[] payment_id, byte[] payment_hash, boolean rejected_by_dest, Option_NetworkUpdateZ network_update, boolean all_paths_failed, RouteHop[] path, Option_u64Z short_channel_id, RouteParameters retry) {
- long ret = bindings.Event_payment_path_failed(payment_id, payment_hash, rejected_by_dest, network_update.ptr, all_paths_failed, path != null ? Arrays.stream(path).mapToLong(path_conv_10 -> path_conv_10 == null ? 0 : path_conv_10.ptr & ~1).toArray() : null, short_channel_id.ptr, retry == null ? 0 : retry.ptr & ~1);
+ long ret = bindings.Event_payment_path_failed(InternalUtils.check_arr_len(payment_id, 32), InternalUtils.check_arr_len(payment_hash, 32), rejected_by_dest, network_update.ptr, all_paths_failed, path != null ? Arrays.stream(path).mapToLong(path_conv_10 -> path_conv_10 == null ? 0 : path_conv_10.ptr & ~1).toArray() : null, short_channel_id.ptr, retry == null ? 0 : retry.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
Event ret_hu_conv = Event.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new ChannelClosed-variant Event
*/
public static Event channel_closed(byte[] channel_id, long user_channel_id, ClosureReason reason) {
- long ret = bindings.Event_channel_closed(channel_id, user_channel_id, reason.ptr);
+ long ret = bindings.Event_channel_closed(InternalUtils.check_arr_len(channel_id, 32), user_channel_id, reason.ptr);
if (ret >= 0 && ret <= 4096) { return null; }
Event ret_hu_conv = Event.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new DiscardFunding-variant Event
*/
public static Event discard_funding(byte[] channel_id, byte[] transaction) {
- long ret = bindings.Event_discard_funding(channel_id, transaction);
+ long ret = bindings.Event_discard_funding(InternalUtils.check_arr_len(channel_id, 32), transaction);
if (ret >= 0 && ret <= 4096) { return null; }
Event ret_hu_conv = Event.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
if (ptr != 0) { bindings.ExpiryTime_free(ptr); }
}
+ long clone_ptr() {
+ long ret = bindings.ExpiryTime_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ExpiryTime
*/
this.script_hash = obj.script_hash;
}
}
+ long clone_ptr() {
+ long ret = bindings.Fallback_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the Fallback
*/
* Utility method to constructs a new PubKeyHash-variant Fallback
*/
public static Fallback pub_key_hash(byte[] a) {
- long ret = bindings.Fallback_pub_key_hash(a);
+ long ret = bindings.Fallback_pub_key_hash(InternalUtils.check_arr_len(a, 20));
if (ret >= 0 && ret <= 4096) { return null; }
Fallback ret_hu_conv = Fallback.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new ScriptHash-variant Fallback
*/
public static Fallback script_hash(byte[] a) {
- long ret = bindings.Fallback_script_hash(a);
+ long ret = bindings.Fallback_script_hash(InternalUtils.check_arr_len(a, 20));
if (ret >= 0 && ret <= 4096) { return null; }
Fallback ret_hu_conv = Fallback.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
WatchedOutput output_hu_conv = null; if (output < 0 || output > 4096) { output_hu_conv = new WatchedOutput(null, output); }
output_hu_conv.ptrs_to.add(this);
Option_C2Tuple_usizeTransactionZZ ret = arg.register_output(output_hu_conv);
- long result = ret.ptr;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
});
* a spending condition.
*/
public void register_tx(byte[] txid, byte[] script_pubkey) {
- bindings.Filter_register_tx(this.ptr, txid, script_pubkey);
+ bindings.Filter_register_tx(this.ptr, InternalUtils.check_arr_len(txid, 32), script_pubkey);
}
/**
* A temporary channel ID, until the funding is established
*/
public void set_temporary_channel_id(byte[] val) {
- bindings.FundingCreated_set_temporary_channel_id(this.ptr, val);
+ bindings.FundingCreated_set_temporary_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* The funding transaction ID
*/
public void set_funding_txid(byte[] val) {
- bindings.FundingCreated_set_funding_txid(this.ptr, val);
+ bindings.FundingCreated_set_funding_txid(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* The signature of the channel initiator (funder) on the initial commitment transaction
*/
public void set_signature(byte[] val) {
- bindings.FundingCreated_set_signature(this.ptr, val);
+ bindings.FundingCreated_set_signature(this.ptr, InternalUtils.check_arr_len(val, 64));
}
/**
* Constructs a new FundingCreated given each field
*/
public static FundingCreated of(byte[] temporary_channel_id_arg, byte[] funding_txid_arg, short funding_output_index_arg, byte[] signature_arg) {
- long ret = bindings.FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
+ long ret = bindings.FundingCreated_new(InternalUtils.check_arr_len(temporary_channel_id_arg, 32), InternalUtils.check_arr_len(funding_txid_arg, 32), funding_output_index_arg, InternalUtils.check_arr_len(signature_arg, 64));
if (ret >= 0 && ret <= 4096) { return null; }
FundingCreated ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new FundingCreated(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.FundingCreated_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the FundingCreated
*/
* The channel ID
*/
public void set_channel_id(byte[] val) {
- bindings.FundingLocked_set_channel_id(this.ptr, val);
+ bindings.FundingLocked_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* The per-commitment point of the second commitment transaction
*/
public void set_next_per_commitment_point(byte[] val) {
- bindings.FundingLocked_set_next_per_commitment_point(this.ptr, val);
+ bindings.FundingLocked_set_next_per_commitment_point(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* Constructs a new FundingLocked given each field
*/
public static FundingLocked of(byte[] channel_id_arg, byte[] next_per_commitment_point_arg) {
- long ret = bindings.FundingLocked_new(channel_id_arg, next_per_commitment_point_arg);
+ long ret = bindings.FundingLocked_new(InternalUtils.check_arr_len(channel_id_arg, 32), InternalUtils.check_arr_len(next_per_commitment_point_arg, 33));
if (ret >= 0 && ret <= 4096) { return null; }
FundingLocked ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new FundingLocked(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.FundingLocked_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the FundingLocked
*/
* The channel ID
*/
public void set_channel_id(byte[] val) {
- bindings.FundingSigned_set_channel_id(this.ptr, val);
+ bindings.FundingSigned_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* The signature of the channel acceptor (fundee) on the initial commitment transaction
*/
public void set_signature(byte[] val) {
- bindings.FundingSigned_set_signature(this.ptr, val);
+ bindings.FundingSigned_set_signature(this.ptr, InternalUtils.check_arr_len(val, 64));
}
/**
* Constructs a new FundingSigned given each field
*/
public static FundingSigned of(byte[] channel_id_arg, byte[] signature_arg) {
- long ret = bindings.FundingSigned_new(channel_id_arg, signature_arg);
+ long ret = bindings.FundingSigned_new(InternalUtils.check_arr_len(channel_id_arg, 32), InternalUtils.check_arr_len(signature_arg, 64));
if (ret >= 0 && ret <= 4096) { return null; }
FundingSigned ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new FundingSigned(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.FundingSigned_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the FundingSigned
*/
* The genesis hash of the blockchain for channel and node information
*/
public void set_chain_hash(byte[] val) {
- bindings.GossipTimestampFilter_set_chain_hash(this.ptr, val);
+ bindings.GossipTimestampFilter_set_chain_hash(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* Constructs a new GossipTimestampFilter given each field
*/
public static GossipTimestampFilter of(byte[] chain_hash_arg, int first_timestamp_arg, int timestamp_range_arg) {
- long ret = bindings.GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
+ long ret = bindings.GossipTimestampFilter_new(InternalUtils.check_arr_len(chain_hash_arg, 32), first_timestamp_arg, timestamp_range_arg);
if (ret >= 0 && ret <= 4096) { return null; }
GossipTimestampFilter ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new GossipTimestampFilter(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.GossipTimestampFilter_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the GossipTimestampFilter
*/
* The hash of the preimage which unlocks this HTLC.
*/
public void set_payment_hash(byte[] val) {
- bindings.HTLCOutputInCommitment_set_payment_hash(this.ptr, val);
+ bindings.HTLCOutputInCommitment_set_payment_hash(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* Constructs a new HTLCOutputInCommitment given each field
*/
public static HTLCOutputInCommitment of(boolean offered_arg, long amount_msat_arg, int cltv_expiry_arg, byte[] payment_hash_arg, Option_u32Z transaction_output_index_arg) {
- long ret = bindings.HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg.ptr);
+ long ret = bindings.HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, InternalUtils.check_arr_len(payment_hash_arg, 32), transaction_output_index_arg.ptr);
if (ret >= 0 && ret <= 4096) { return null; }
HTLCOutputInCommitment ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new HTLCOutputInCommitment(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.HTLCOutputInCommitment_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the HTLCOutputInCommitment
*/
if (ptr != 0) { bindings.HTLCUpdate_free(ptr); }
}
+ long clone_ptr() {
+ long ret = bindings.HTLCUpdate_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the HTLCUpdate
*/
* Our counterparty's signature for the transaction
*/
public void set_counterparty_sig(byte[] val) {
- bindings.HolderCommitmentTransaction_set_counterparty_sig(this.ptr, val);
+ bindings.HolderCommitmentTransaction_set_counterparty_sig(this.ptr, InternalUtils.check_arr_len(val, 64));
}
/**
* All non-dust counterparty HTLC signatures, in the order they appear in the transaction
*/
public void set_counterparty_htlc_sigs(byte[][] val) {
- bindings.HolderCommitmentTransaction_set_counterparty_htlc_sigs(this.ptr, val);
+ bindings.HolderCommitmentTransaction_set_counterparty_htlc_sigs(this.ptr, val != null ? Arrays.stream(val).map(val_conv_8 -> InternalUtils.check_arr_len(val_conv_8, 64)).toArray(byte[][]::new) : null);
+ }
+
+ long clone_ptr() {
+ long ret = bindings.HolderCommitmentTransaction_clone_ptr(this.ptr);
+ return ret;
}
/**
* The funding keys are used to figure out which signature should go first when building the transaction for broadcast.
*/
public static HolderCommitmentTransaction of(CommitmentTransaction commitment_tx, byte[] counterparty_sig, byte[][] counterparty_htlc_sigs, byte[] holder_funding_key, byte[] counterparty_funding_key) {
- long ret = bindings.HolderCommitmentTransaction_new(commitment_tx == null ? 0 : commitment_tx.ptr & ~1, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
+ long ret = bindings.HolderCommitmentTransaction_new(commitment_tx == null ? 0 : commitment_tx.ptr & ~1, InternalUtils.check_arr_len(counterparty_sig, 64), counterparty_htlc_sigs != null ? Arrays.stream(counterparty_htlc_sigs).map(counterparty_htlc_sigs_conv_8 -> InternalUtils.check_arr_len(counterparty_htlc_sigs_conv_8, 64)).toArray(byte[][]::new) : null, InternalUtils.check_arr_len(holder_funding_key, 33), InternalUtils.check_arr_len(counterparty_funding_key, 33));
if (ret >= 0 && ret <= 4096) { return null; }
HolderCommitmentTransaction ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new HolderCommitmentTransaction(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Private key of anchor tx
*/
public void set_funding_key(byte[] val) {
- bindings.InMemorySigner_set_funding_key(this.ptr, val);
+ bindings.InMemorySigner_set_funding_key(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* Holder secret key for blinded revocation pubkey
*/
public void set_revocation_base_key(byte[] val) {
- bindings.InMemorySigner_set_revocation_base_key(this.ptr, val);
+ bindings.InMemorySigner_set_revocation_base_key(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* Holder secret key used for our balance in counterparty-broadcasted commitment transactions
*/
public void set_payment_key(byte[] val) {
- bindings.InMemorySigner_set_payment_key(this.ptr, val);
+ bindings.InMemorySigner_set_payment_key(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* Holder secret key used in HTLC tx
*/
public void set_delayed_payment_base_key(byte[] val) {
- bindings.InMemorySigner_set_delayed_payment_base_key(this.ptr, val);
+ bindings.InMemorySigner_set_delayed_payment_base_key(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* Holder htlc secret key used in commitment tx htlc outputs
*/
public void set_htlc_base_key(byte[] val) {
- bindings.InMemorySigner_set_htlc_base_key(this.ptr, val);
+ bindings.InMemorySigner_set_htlc_base_key(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* Commitment seed
*/
public void set_commitment_seed(byte[] val) {
- bindings.InMemorySigner_set_commitment_seed(this.ptr, val);
+ bindings.InMemorySigner_set_commitment_seed(this.ptr, InternalUtils.check_arr_len(val, 32));
+ }
+
+ long clone_ptr() {
+ long ret = bindings.InMemorySigner_clone_ptr(this.ptr);
+ return ret;
}
/**
* Create a new InMemorySigner
*/
public static InMemorySigner of(byte[] funding_key, byte[] revocation_base_key, byte[] payment_key, byte[] delayed_payment_base_key, byte[] htlc_base_key, byte[] commitment_seed, long channel_value_satoshis, byte[] channel_keys_id) {
- long ret = bindings.InMemorySigner_new(funding_key, revocation_base_key, payment_key, delayed_payment_base_key, htlc_base_key, commitment_seed, channel_value_satoshis, channel_keys_id);
+ long ret = bindings.InMemorySigner_new(InternalUtils.check_arr_len(funding_key, 32), InternalUtils.check_arr_len(revocation_base_key, 32), InternalUtils.check_arr_len(payment_key, 32), InternalUtils.check_arr_len(delayed_payment_base_key, 32), InternalUtils.check_arr_len(htlc_base_key, 32), InternalUtils.check_arr_len(commitment_seed, 32), channel_value_satoshis, InternalUtils.check_arr_len(channel_keys_id, 32));
if (ret >= 0 && ret <= 4096) { return null; }
InMemorySigner ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new InMemorySigner(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.Init_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the Init
*/
return ret;
}
+ long clone_ptr() {
+ long ret = bindings.InitFeatures_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the InitFeatures
*/
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.InvalidShutdownScript_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the InvalidShutdownScript
*/
return ret;
}
+ long clone_ptr() {
+ long ret = bindings.Invoice_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the Invoice
*/
return ret;
}
+ long clone_ptr() {
+ long ret = bindings.InvoiceFeatures_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the InvoiceFeatures
*/
* [`EventHandler`]. Otherwise, calling this method is unnecessary.
*/
public void remove_cached_payment(byte[] payment_hash) {
- bindings.InvoicePayer_remove_cached_payment(this.ptr, payment_hash);
+ bindings.InvoicePayer_remove_cached_payment(this.ptr, InternalUtils.check_arr_len(payment_hash, 32));
}
/**
if (ptr != 0) { bindings.InvoiceSignature_free(ptr); }
}
+ long clone_ptr() {
+ long ret = bindings.InvoiceSignature_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the InvoiceSignature
*/
impl_holder.held = new KeysInterface(new bindings.LDKKeysInterface() {
@Override public byte[] get_node_secret() {
byte[] ret = arg.get_node_secret();
- return ret;
+ byte[] result = InternalUtils.check_arr_len(ret, 32);
+ return result;
}
@Override public byte[] get_destination_script() {
byte[] ret = arg.get_destination_script();
}
@Override public long get_shutdown_scriptpubkey() {
ShutdownScript ret = arg.get_shutdown_scriptpubkey();
- long result = ret == null ? 0 : ret.ptr & ~1;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
@Override public long get_channel_signer(boolean inbound, long channel_value_satoshis) {
Sign ret = arg.get_channel_signer(inbound, channel_value_satoshis);
- long result = ret == null ? 0 : ret.ptr;
+ long result = ret == null ? 0 : ret.clone_ptr();
impl_holder.held.ptrs_to.add(ret);
return result;
}
@Override public byte[] get_secure_random_bytes() {
byte[] ret = arg.get_secure_random_bytes();
- return ret;
+ byte[] result = InternalUtils.check_arr_len(ret, 32);
+ return result;
}
@Override public long read_chan_signer(byte[] reader) {
Result_SignDecodeErrorZ ret = arg.read_chan_signer(reader);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
@Override public long sign_invoice(byte[] invoice_preimage) {
Result_RecoverableSignatureNoneZ ret = arg.sign_invoice(invoice_preimage);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
});
* detailed description of the guarantee.
*/
public static KeysManager of(byte[] seed, long starting_time_secs, int starting_time_nanos) {
- long ret = bindings.KeysManager_new(seed, starting_time_secs, starting_time_nanos);
+ long ret = bindings.KeysManager_new(InternalUtils.check_arr_len(seed, 32), starting_time_secs, starting_time_nanos);
if (ret >= 0 && ret <= 4096) { return null; }
KeysManager ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new KeysManager(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* onchain output detection for which a corresponding delayed_payment_key must be derived.
*/
public InMemorySigner derive_channel_keys(long channel_value_satoshis, byte[] params) {
- long ret = bindings.KeysManager_derive_channel_keys(this.ptr, channel_value_satoshis, params);
+ long ret = bindings.KeysManager_derive_channel_keys(this.ptr, channel_value_satoshis, InternalUtils.check_arr_len(params, 32));
if (ret >= 0 && ret <= 4096) { return null; }
InMemorySigner ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new InMemorySigner(null, ret); }
ret_hu_conv.ptrs_to.add(this);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.LightningError_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the LightningError
*/
* Notifies the listener that a block was removed at the given height.
*/
public void block_disconnected(byte[] header, int height) {
- bindings.Listen_block_disconnected(this.ptr, header, height);
+ bindings.Listen_block_disconnected(this.ptr, InternalUtils.check_arr_len(header, 80), height);
}
}
/**
* Logs the `Record`
*/
- void log(String record);
+ void log(Record record);
}
private static class LDKLoggerHolder { Logger held; }
public static Logger new_impl(LoggerInterface arg) {
final LDKLoggerHolder impl_holder = new LDKLoggerHolder();
impl_holder.held = new Logger(new bindings.LDKLogger() {
- @Override public void log(String record) {
- arg.log(record);
+ @Override public void log(long record) {
+ Record record_hu_conv = null; if (record < 0 || record > 4096) { record_hu_conv = new Record(null, record); }
+ arg.log(record_hu_conv);
}
});
return impl_holder.held;
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * Used to indicate that we've accepted a channel open and should send the accept_channel
+ * message provided to the given peer.
+ */
public final static class SendAcceptChannel extends MessageSendEvent {
/**
* The node_id of the node which should receive this message
this.msg = msg_hu_conv;
}
}
+ /**
+ * Used to indicate that we've initiated a channel open and should send the open_channel
+ * message provided to the given peer.
+ */
public final static class SendOpenChannel extends MessageSendEvent {
/**
* The node_id of the node which should receive this message
this.msg = msg_hu_conv;
}
}
+ /**
+ * Used to indicate that a funding_created message should be sent to the peer with the given node_id.
+ */
public final static class SendFundingCreated extends MessageSendEvent {
/**
* The node_id of the node which should receive this message
this.msg = msg_hu_conv;
}
}
+ /**
+ * Used to indicate that a funding_signed message should be sent to the peer with the given node_id.
+ */
public final static class SendFundingSigned extends MessageSendEvent {
/**
* The node_id of the node which should receive this message
this.msg = msg_hu_conv;
}
}
+ /**
+ * Used to indicate that a funding_locked message should be sent to the peer with the given node_id.
+ */
public final static class SendFundingLocked extends MessageSendEvent {
/**
* The node_id of the node which should receive these message(s)
this.msg = msg_hu_conv;
}
}
+ /**
+ * Used to indicate that an announcement_signatures message should be sent to the peer with the given node_id.
+ */
public final static class SendAnnouncementSignatures extends MessageSendEvent {
/**
* The node_id of the node which should receive these message(s)
this.msg = msg_hu_conv;
}
}
+ /**
+ * Used to indicate that a series of HTLC update messages, as well as a commitment_signed
+ * message should be sent to the peer with the given node_id.
+ */
public final static class UpdateHTLCs extends MessageSendEvent {
/**
* The node_id of the node which should receive these message(s)
this.updates = updates_hu_conv;
}
}
+ /**
+ * Used to indicate that a revoke_and_ack message should be sent to the peer with the given node_id.
+ */
public final static class SendRevokeAndACK extends MessageSendEvent {
/**
* The node_id of the node which should receive this message
this.msg = msg_hu_conv;
}
}
+ /**
+ * Used to indicate that a closing_signed message should be sent to the peer with the given node_id.
+ */
public final static class SendClosingSigned extends MessageSendEvent {
/**
* The node_id of the node which should receive this message
this.msg = msg_hu_conv;
}
}
+ /**
+ * Used to indicate that a shutdown message should be sent to the peer with the given node_id.
+ */
public final static class SendShutdown extends MessageSendEvent {
/**
* The node_id of the node which should receive this message
this.msg = msg_hu_conv;
}
}
+ /**
+ * Used to indicate that a channel_reestablish message should be sent to the peer with the given node_id.
+ */
public final static class SendChannelReestablish extends MessageSendEvent {
/**
* The node_id of the node which should receive this message
this.msg = msg_hu_conv;
}
}
+ /**
+ * Used to indicate that a channel_announcement and channel_update should be broadcast to all
+ * peers (except the peer with node_id either msg.contents.node_id_1 or msg.contents.node_id_2).
+ *
+ * Note that after doing so, you very likely (unless you did so very recently) want to call
+ * ChannelManager::broadcast_node_announcement to trigger a BroadcastNodeAnnouncement event.
+ * This ensures that any nodes which see our channel_announcement also have a relevant
+ * node_announcement, including relevant feature flags which may be important for routing
+ * through or to us.
+ */
public final static class BroadcastChannelAnnouncement extends MessageSendEvent {
/**
* The channel_announcement which should be sent.
this.update_msg = update_msg_hu_conv;
}
}
+ /**
+ * Used to indicate that a node_announcement should be broadcast to all peers.
+ */
public final static class BroadcastNodeAnnouncement extends MessageSendEvent {
/**
* The node_announcement which should be sent.
this.msg = msg_hu_conv;
}
}
+ /**
+ * Used to indicate that a channel_update should be broadcast to all peers.
+ */
public final static class BroadcastChannelUpdate extends MessageSendEvent {
/**
* The channel_update which should be sent.
this.msg = msg_hu_conv;
}
}
+ /**
+ * Used to indicate that a channel_update should be sent to a single peer.
+ * In contrast to [`Self::BroadcastChannelUpdate`], this is used when the channel is a
+ * private channel and we shouldn't be informing all of our peers of channel parameters.
+ */
public final static class SendChannelUpdate extends MessageSendEvent {
/**
* The node_id of the node which should receive this message
this.msg = msg_hu_conv;
}
}
+ /**
+ * Broadcast an error downstream to be handled
+ */
public final static class HandleError extends MessageSendEvent {
/**
* The node_id of the node which should receive this message
this.action = action_hu_conv;
}
}
+ /**
+ * Query a peer for channels with funding transaction UTXOs in a block range.
+ */
public final static class SendChannelRangeQuery extends MessageSendEvent {
/**
* The node_id of this message recipient
this.msg = msg_hu_conv;
}
}
+ /**
+ * Request routing gossip messages from a peer for a list of channels identified by
+ * their short_channel_ids.
+ */
public final static class SendShortIdsQuery extends MessageSendEvent {
/**
* The node_id of this message recipient
this.msg = msg_hu_conv;
}
}
+ /**
+ * Sends a reply to a channel range query. This may be one of several SendReplyChannelRange events
+ * emitted during processing of the query.
+ */
public final static class SendReplyChannelRange extends MessageSendEvent {
/**
* The node_id of this message recipient
this.msg = msg_hu_conv;
}
}
+ long clone_ptr() {
+ long ret = bindings.MessageSendEvent_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the MessageSendEvent
*/
* Utility method to constructs a new SendAcceptChannel-variant MessageSendEvent
*/
public static MessageSendEvent send_accept_channel(byte[] node_id, AcceptChannel msg) {
- long ret = bindings.MessageSendEvent_send_accept_channel(node_id, msg == null ? 0 : msg.ptr & ~1);
+ long ret = bindings.MessageSendEvent_send_accept_channel(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new SendOpenChannel-variant MessageSendEvent
*/
public static MessageSendEvent send_open_channel(byte[] node_id, OpenChannel msg) {
- long ret = bindings.MessageSendEvent_send_open_channel(node_id, msg == null ? 0 : msg.ptr & ~1);
+ long ret = bindings.MessageSendEvent_send_open_channel(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new SendFundingCreated-variant MessageSendEvent
*/
public static MessageSendEvent send_funding_created(byte[] node_id, FundingCreated msg) {
- long ret = bindings.MessageSendEvent_send_funding_created(node_id, msg == null ? 0 : msg.ptr & ~1);
+ long ret = bindings.MessageSendEvent_send_funding_created(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new SendFundingSigned-variant MessageSendEvent
*/
public static MessageSendEvent send_funding_signed(byte[] node_id, FundingSigned msg) {
- long ret = bindings.MessageSendEvent_send_funding_signed(node_id, msg == null ? 0 : msg.ptr & ~1);
+ long ret = bindings.MessageSendEvent_send_funding_signed(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new SendFundingLocked-variant MessageSendEvent
*/
public static MessageSendEvent send_funding_locked(byte[] node_id, FundingLocked msg) {
- long ret = bindings.MessageSendEvent_send_funding_locked(node_id, msg == null ? 0 : msg.ptr & ~1);
+ long ret = bindings.MessageSendEvent_send_funding_locked(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new SendAnnouncementSignatures-variant MessageSendEvent
*/
public static MessageSendEvent send_announcement_signatures(byte[] node_id, AnnouncementSignatures msg) {
- long ret = bindings.MessageSendEvent_send_announcement_signatures(node_id, msg == null ? 0 : msg.ptr & ~1);
+ long ret = bindings.MessageSendEvent_send_announcement_signatures(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new UpdateHTLCs-variant MessageSendEvent
*/
public static MessageSendEvent update_htlcs(byte[] node_id, CommitmentUpdate updates) {
- long ret = bindings.MessageSendEvent_update_htlcs(node_id, updates == null ? 0 : updates.ptr & ~1);
+ long ret = bindings.MessageSendEvent_update_htlcs(InternalUtils.check_arr_len(node_id, 33), updates == null ? 0 : updates.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new SendRevokeAndACK-variant MessageSendEvent
*/
public static MessageSendEvent send_revoke_and_ack(byte[] node_id, RevokeAndACK msg) {
- long ret = bindings.MessageSendEvent_send_revoke_and_ack(node_id, msg == null ? 0 : msg.ptr & ~1);
+ long ret = bindings.MessageSendEvent_send_revoke_and_ack(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new SendClosingSigned-variant MessageSendEvent
*/
public static MessageSendEvent send_closing_signed(byte[] node_id, ClosingSigned msg) {
- long ret = bindings.MessageSendEvent_send_closing_signed(node_id, msg == null ? 0 : msg.ptr & ~1);
+ long ret = bindings.MessageSendEvent_send_closing_signed(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new SendShutdown-variant MessageSendEvent
*/
public static MessageSendEvent send_shutdown(byte[] node_id, Shutdown msg) {
- long ret = bindings.MessageSendEvent_send_shutdown(node_id, msg == null ? 0 : msg.ptr & ~1);
+ long ret = bindings.MessageSendEvent_send_shutdown(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new SendChannelReestablish-variant MessageSendEvent
*/
public static MessageSendEvent send_channel_reestablish(byte[] node_id, ChannelReestablish msg) {
- long ret = bindings.MessageSendEvent_send_channel_reestablish(node_id, msg == null ? 0 : msg.ptr & ~1);
+ long ret = bindings.MessageSendEvent_send_channel_reestablish(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new SendChannelUpdate-variant MessageSendEvent
*/
public static MessageSendEvent send_channel_update(byte[] node_id, ChannelUpdate msg) {
- long ret = bindings.MessageSendEvent_send_channel_update(node_id, msg == null ? 0 : msg.ptr & ~1);
+ long ret = bindings.MessageSendEvent_send_channel_update(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new HandleError-variant MessageSendEvent
*/
public static MessageSendEvent handle_error(byte[] node_id, ErrorAction action) {
- long ret = bindings.MessageSendEvent_handle_error(node_id, action.ptr);
+ long ret = bindings.MessageSendEvent_handle_error(InternalUtils.check_arr_len(node_id, 33), action.ptr);
if (ret >= 0 && ret <= 4096) { return null; }
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new SendChannelRangeQuery-variant MessageSendEvent
*/
public static MessageSendEvent send_channel_range_query(byte[] node_id, QueryChannelRange msg) {
- long ret = bindings.MessageSendEvent_send_channel_range_query(node_id, msg == null ? 0 : msg.ptr & ~1);
+ long ret = bindings.MessageSendEvent_send_channel_range_query(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new SendShortIdsQuery-variant MessageSendEvent
*/
public static MessageSendEvent send_short_ids_query(byte[] node_id, QueryShortChannelIds msg) {
- long ret = bindings.MessageSendEvent_send_short_ids_query(node_id, msg == null ? 0 : msg.ptr & ~1);
+ long ret = bindings.MessageSendEvent_send_short_ids_query(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new SendReplyChannelRange-variant MessageSendEvent
*/
public static MessageSendEvent send_reply_channel_range(byte[] node_id, ReplyChannelRange msg) {
- long ret = bindings.MessageSendEvent_send_reply_channel_range(node_id, msg == null ? 0 : msg.ptr & ~1);
+ long ret = bindings.MessageSendEvent_send_reply_channel_range(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
impl_holder.held = new MessageSendEventsProvider(new bindings.LDKMessageSendEventsProvider() {
@Override public long[] get_and_clear_pending_msg_events() {
MessageSendEvent[] ret = arg.get_and_clear_pending_msg_events();
- long[] result = ret != null ? Arrays.stream(ret).mapToLong(ret_conv_18 -> ret_conv_18.ptr).toArray() : null;
+ long[] result = ret != null ? Arrays.stream(ret).mapToLong(ret_conv_18 -> ret_conv_18 == null ? 0 : ret_conv_18.clone_ptr()).toArray() : null;
return result;
}
});
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.MinFinalCltvExpiry_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the MinFinalCltvExpiry
*/
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * A monitor event containing an HTLCUpdate.
+ */
public final static class HTLCEvent extends MonitorEvent {
public final HTLCUpdate htlc_event;
private HTLCEvent(long ptr, bindings.LDKMonitorEvent.HTLCEvent obj) {
this.htlc_event = htlc_event_hu_conv;
}
}
+ /**
+ * A monitor event that the Channel's commitment transaction was confirmed.
+ */
public final static class CommitmentTxConfirmed extends MonitorEvent {
public final OutPoint commitment_tx_confirmed;
private CommitmentTxConfirmed(long ptr, bindings.LDKMonitorEvent.CommitmentTxConfirmed obj) {
this.commitment_tx_confirmed = commitment_tx_confirmed_hu_conv;
}
}
+ /**
+ * Indicates a [`ChannelMonitor`] update has completed. See
+ * [`ChannelMonitorUpdateErr::TemporaryFailure`] for more information on how this is used.
+ *
+ * [`ChannelMonitorUpdateErr::TemporaryFailure`]: super::ChannelMonitorUpdateErr::TemporaryFailure
+ */
public final static class UpdateCompleted extends MonitorEvent {
/**
* The funding outpoint of the [`ChannelMonitor`] that was updated
this.monitor_update_id = obj.monitor_update_id;
}
}
+ /**
+ * Indicates a [`ChannelMonitor`] update has failed. See
+ * [`ChannelMonitorUpdateErr::PermanentFailure`] for more information on how this is used.
+ *
+ * [`ChannelMonitorUpdateErr::PermanentFailure`]: super::ChannelMonitorUpdateErr::PermanentFailure
+ */
public final static class UpdateFailed extends MonitorEvent {
public final OutPoint update_failed;
private UpdateFailed(long ptr, bindings.LDKMonitorEvent.UpdateFailed obj) {
this.update_failed = update_failed_hu_conv;
}
}
+ long clone_ptr() {
+ long ret = bindings.MonitorEvent_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the MonitorEvent
*/
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.MonitorUpdateError_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the MonitorUpdateError
*/
if (ptr != 0) { bindings.MonitorUpdateId_free(ptr); }
}
+ long clone_ptr() {
+ long ret = bindings.MonitorUpdateId_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the MonitorUpdateId
*/
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * An IPv4 address/port on which the peer is listening.
+ */
public final static class IPv4 extends NetAddress {
/**
* The 4-byte IPv4 address
this.port = obj.port;
}
}
+ /**
+ * An IPv6 address/port on which the peer is listening.
+ */
public final static class IPv6 extends NetAddress {
/**
* The 16-byte IPv6 address
this.port = obj.port;
}
}
+ /**
+ * An old-style Tor onion address/port on which the peer is listening.
+ */
public final static class OnionV2 extends NetAddress {
/**
* The bytes (usually encoded in base32 with \".onion\" appended)
this.port = obj.port;
}
}
+ /**
+ * A new-style Tor onion address/port on which the peer is listening.
+ * To create the human-readable \"hostname\", concatenate ed25519_pubkey, checksum, and version,
+ * wrap as base32 and append \".onion\".
+ */
public final static class OnionV3 extends NetAddress {
/**
* The ed25519 long-term public key of the peer
this.port = obj.port;
}
}
+ long clone_ptr() {
+ long ret = bindings.NetAddress_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the NetAddress
*/
* Utility method to constructs a new IPv4-variant NetAddress
*/
public static NetAddress ipv4(byte[] addr, short port) {
- long ret = bindings.NetAddress_ipv4(addr, port);
+ long ret = bindings.NetAddress_ipv4(InternalUtils.check_arr_len(addr, 4), port);
if (ret >= 0 && ret <= 4096) { return null; }
NetAddress ret_hu_conv = NetAddress.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new IPv6-variant NetAddress
*/
public static NetAddress ipv6(byte[] addr, short port) {
- long ret = bindings.NetAddress_ipv6(addr, port);
+ long ret = bindings.NetAddress_ipv6(InternalUtils.check_arr_len(addr, 16), port);
if (ret >= 0 && ret <= 4096) { return null; }
NetAddress ret_hu_conv = NetAddress.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new OnionV2-variant NetAddress
*/
public static NetAddress onion_v2(byte[] addr, short port) {
- long ret = bindings.NetAddress_onion_v2(addr, port);
+ long ret = bindings.NetAddress_onion_v2(InternalUtils.check_arr_len(addr, 10), port);
if (ret >= 0 && ret <= 4096) { return null; }
NetAddress ret_hu_conv = NetAddress.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new OnionV3-variant NetAddress
*/
public static NetAddress onion_v3(byte[] ed25519_pubkey, short checksum, byte version, short port) {
- long ret = bindings.NetAddress_onion_v3(ed25519_pubkey, checksum, version, port);
+ long ret = bindings.NetAddress_onion_v3(InternalUtils.check_arr_len(ed25519_pubkey, 32), checksum, version, port);
if (ret >= 0 && ret <= 4096) { return null; }
NetAddress ret_hu_conv = NetAddress.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
NetGraphMsgHandler ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new NetGraphMsgHandler(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
ret_hu_conv.ptrs_to.add(network_graph);
+ ret_hu_conv.ptrs_to.add(chain_access);
ret_hu_conv.ptrs_to.add(logger);
return ret_hu_conv;
}
*/
public void add_chain_access(Option_AccessZ chain_access) {
bindings.NetGraphMsgHandler_add_chain_access(this.ptr, chain_access.ptr);
+ this.ptrs_to.add(chain_access);
}
/**
if (ptr != 0) { bindings.NetworkGraph_free(ptr); }
}
+ long clone_ptr() {
+ long ret = bindings.NetworkGraph_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the NetworkGraph
*/
* Creates a new, empty, network graph.
*/
public static NetworkGraph of(byte[] genesis_hash) {
- long ret = bindings.NetworkGraph_new(genesis_hash);
+ long ret = bindings.NetworkGraph_new(InternalUtils.check_arr_len(genesis_hash, 32));
if (ret >= 0 && ret <= 4096) { return null; }
NetworkGraph ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new NetworkGraph(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
if (ret >= 0 && ret <= 4096) { return null; }
Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
this.ptrs_to.add(msg);
+ this.ptrs_to.add(chain_access);
return ret_hu_conv;
}
if (ret >= 0 && ret <= 4096) { return null; }
Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
this.ptrs_to.add(msg);
+ this.ptrs_to.add(chain_access);
return ret_hu_conv;
}
* Marks a node in the graph as failed.
*/
public void fail_node(byte[] _node_id, boolean is_permanent) {
- bindings.NetworkGraph_fail_node(this.ptr, _node_id, is_permanent);
+ bindings.NetworkGraph_fail_node(this.ptr, InternalUtils.check_arr_len(_node_id, 33), is_permanent);
}
/**
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * An error indicating a `channel_update` messages should be applied via
+ * [`NetworkGraph::update_channel`].
+ */
public final static class ChannelUpdateMessage extends NetworkUpdate {
/**
* The update to apply via [`NetworkGraph::update_channel`].
this.msg = msg_hu_conv;
}
}
+ /**
+ * An error indicating only that a channel has been closed, which should be applied via
+ * [`NetworkGraph::close_channel_from_update`].
+ */
public final static class ChannelClosed extends NetworkUpdate {
/**
* The short channel id of the closed channel.
this.is_permanent = obj.is_permanent;
}
}
+ /**
+ * An error indicating only that a node has failed, which should be applied via
+ * [`NetworkGraph::fail_node`].
+ */
public final static class NodeFailure extends NetworkUpdate {
/**
* The node id of the failed node.
this.is_permanent = obj.is_permanent;
}
}
+ long clone_ptr() {
+ long ret = bindings.NetworkUpdate_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the NetworkUpdate
*/
* Utility method to constructs a new NodeFailure-variant NetworkUpdate
*/
public static NetworkUpdate node_failure(byte[] node_id, boolean is_permanent) {
- long ret = bindings.NetworkUpdate_node_failure(node_id, is_permanent);
+ long ret = bindings.NetworkUpdate_node_failure(InternalUtils.check_arr_len(node_id, 33), is_permanent);
if (ret >= 0 && ret <= 4096) { return null; }
NetworkUpdate ret_hu_conv = NetworkUpdate.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* The signature by the node key
*/
public void set_signature(byte[] val) {
- bindings.NodeAnnouncement_set_signature(this.ptr, val);
+ bindings.NodeAnnouncement_set_signature(this.ptr, InternalUtils.check_arr_len(val, 64));
}
/**
* Constructs a new NodeAnnouncement given each field
*/
public static NodeAnnouncement of(byte[] signature_arg, UnsignedNodeAnnouncement contents_arg) {
- long ret = bindings.NodeAnnouncement_new(signature_arg, contents_arg == null ? 0 : contents_arg.ptr & ~1);
+ long ret = bindings.NodeAnnouncement_new(InternalUtils.check_arr_len(signature_arg, 64), contents_arg == null ? 0 : contents_arg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
NodeAnnouncement ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new NodeAnnouncement(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.NodeAnnouncement_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the NodeAnnouncement
*/
* Color assigned to the node
*/
public void set_rgb(byte[] val) {
- bindings.NodeAnnouncementInfo_set_rgb(this.ptr, val);
+ bindings.NodeAnnouncementInfo_set_rgb(this.ptr, InternalUtils.check_arr_len(val, 3));
}
/**
* should not be exposed to the user.
*/
public void set_alias(byte[] val) {
- bindings.NodeAnnouncementInfo_set_alias(this.ptr, val);
+ bindings.NodeAnnouncementInfo_set_alias(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* Constructs a new NodeAnnouncementInfo given each field
*/
public static NodeAnnouncementInfo of(NodeFeatures features_arg, int last_update_arg, byte[] rgb_arg, byte[] alias_arg, NetAddress[] addresses_arg, NodeAnnouncement announcement_message_arg) {
- long ret = bindings.NodeAnnouncementInfo_new(features_arg == null ? 0 : features_arg.ptr & ~1, last_update_arg, rgb_arg, alias_arg, addresses_arg != null ? Arrays.stream(addresses_arg).mapToLong(addresses_arg_conv_12 -> addresses_arg_conv_12.ptr).toArray() : null, announcement_message_arg == null ? 0 : announcement_message_arg.ptr & ~1);
+ long ret = bindings.NodeAnnouncementInfo_new(features_arg == null ? 0 : features_arg.ptr & ~1, last_update_arg, InternalUtils.check_arr_len(rgb_arg, 3), InternalUtils.check_arr_len(alias_arg, 32), addresses_arg != null ? Arrays.stream(addresses_arg).mapToLong(addresses_arg_conv_12 -> addresses_arg_conv_12.ptr).toArray() : null, announcement_message_arg == null ? 0 : announcement_message_arg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
NodeAnnouncementInfo ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new NodeAnnouncementInfo(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.NodeAnnouncementInfo_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the NodeAnnouncementInfo
*/
return ret;
}
+ long clone_ptr() {
+ long ret = bindings.NodeFeatures_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the NodeFeatures
*/
if (ptr != 0) { bindings.NodeId_free(ptr); }
}
+ long clone_ptr() {
+ long ret = bindings.NodeId_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the NodeId
*/
* Create a new NodeId from a public key
*/
public static NodeId from_pubkey(byte[] pubkey) {
- long ret = bindings.NodeId_from_pubkey(pubkey);
+ long ret = bindings.NodeId_from_pubkey(InternalUtils.check_arr_len(pubkey, 33));
if (ret >= 0 && ret <= 4096) { return null; }
NodeId ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new NodeId(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.NodeInfo_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the NodeInfo
*/
* The genesis hash of the blockchain where the channel is to be opened
*/
public void set_chain_hash(byte[] val) {
- bindings.OpenChannel_set_chain_hash(this.ptr, val);
+ bindings.OpenChannel_set_chain_hash(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* A temporary channel ID, until the funding outpoint is announced
*/
public void set_temporary_channel_id(byte[] val) {
- bindings.OpenChannel_set_temporary_channel_id(this.ptr, val);
+ bindings.OpenChannel_set_temporary_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* The sender's key controlling the funding transaction
*/
public void set_funding_pubkey(byte[] val) {
- bindings.OpenChannel_set_funding_pubkey(this.ptr, val);
+ bindings.OpenChannel_set_funding_pubkey(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* Used to derive a revocation key for transactions broadcast by counterparty
*/
public void set_revocation_basepoint(byte[] val) {
- bindings.OpenChannel_set_revocation_basepoint(this.ptr, val);
+ bindings.OpenChannel_set_revocation_basepoint(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* A payment key to sender for transactions broadcast by counterparty
*/
public void set_payment_point(byte[] val) {
- bindings.OpenChannel_set_payment_point(this.ptr, val);
+ bindings.OpenChannel_set_payment_point(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* Used to derive a payment key to sender for transactions broadcast by sender
*/
public void set_delayed_payment_basepoint(byte[] val) {
- bindings.OpenChannel_set_delayed_payment_basepoint(this.ptr, val);
+ bindings.OpenChannel_set_delayed_payment_basepoint(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* Used to derive an HTLC payment key to sender
*/
public void set_htlc_basepoint(byte[] val) {
- bindings.OpenChannel_set_htlc_basepoint(this.ptr, val);
+ bindings.OpenChannel_set_htlc_basepoint(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* The first to-be-broadcast-by-sender transaction's per commitment point
*/
public void set_first_per_commitment_point(byte[] val) {
- bindings.OpenChannel_set_first_per_commitment_point(this.ptr, val);
+ bindings.OpenChannel_set_first_per_commitment_point(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
bindings.OpenChannel_set_channel_flags(this.ptr, val);
}
+ long clone_ptr() {
+ long ret = bindings.OpenChannel_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the OpenChannel
*/
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * When we're in this state, this COption_AccessZ contains a crate::lightning::chain::Access
+ */
public final static class Some extends Option_AccessZ {
public final Access some;
private Some(long ptr, bindings.LDKCOption_AccessZ.Some obj) {
this.some = ret_hu_conv;
}
}
+ /**
+ * When we're in this state, this COption_AccessZ contains nothing
+ */
public final static class None extends Option_AccessZ {
private None(long ptr, bindings.LDKCOption_AccessZ.None obj) {
super(null, ptr);
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * When we're in this state, this COption_C2Tuple_usizeTransactionZZ contains a crate::c_types::derived::C2Tuple_usizeTransactionZ
+ */
public final static class Some extends Option_C2Tuple_usizeTransactionZZ {
public final TwoTuple_usizeTransactionZ some;
private Some(long ptr, bindings.LDKCOption_C2Tuple_usizeTransactionZZ.Some obj) {
this.some = some_hu_conv;
}
}
+ /**
+ * When we're in this state, this COption_C2Tuple_usizeTransactionZZ contains nothing
+ */
public final static class None extends Option_C2Tuple_usizeTransactionZZ {
private None(long ptr, bindings.LDKCOption_C2Tuple_usizeTransactionZZ.None obj) {
super(null, ptr);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.COption_C2Tuple_usizeTransactionZZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new COption_C2Tuple_usizeTransactionZZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * When we're in this state, this COption_CVec_NetAddressZZ contains a crate::c_types::derived::CVec_NetAddressZ
+ */
public final static class Some extends Option_CVec_NetAddressZZ {
public final NetAddress[] some;
private Some(long ptr, bindings.LDKCOption_CVec_NetAddressZZ.Some obj) {
this.some = some_conv_12_arr;
}
}
+ /**
+ * When we're in this state, this COption_CVec_NetAddressZZ contains nothing
+ */
public final static class None extends Option_CVec_NetAddressZZ {
private None(long ptr, bindings.LDKCOption_CVec_NetAddressZZ.None obj) {
super(null, ptr);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.COption_CVec_NetAddressZZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new COption_CVec_NetAddressZZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
--- /dev/null
+package org.ldk.structs;
+
+import org.ldk.impl.bindings;
+import org.ldk.enums.*;
+import org.ldk.util.*;
+import java.util.Arrays;
+import javax.annotation.Nullable;
+
+
+/**
+ * An enum which can either contain a crate::lightning::util::events::ClosureReason or not
+ */
+@SuppressWarnings("unchecked") // We correctly assign various generic arrays
+public class Option_ClosureReasonZ extends CommonBase {
+ private Option_ClosureReasonZ(Object _dummy, long ptr) { super(ptr); }
+ @Override @SuppressWarnings("deprecation")
+ protected void finalize() throws Throwable {
+ super.finalize();
+ if (ptr != 0) { bindings.COption_ClosureReasonZ_free(ptr); }
+ }
+ static Option_ClosureReasonZ constr_from_ptr(long ptr) {
+ bindings.LDKCOption_ClosureReasonZ raw_val = bindings.LDKCOption_ClosureReasonZ_ref_from_ptr(ptr);
+ if (raw_val.getClass() == bindings.LDKCOption_ClosureReasonZ.Some.class) {
+ return new Some(ptr, (bindings.LDKCOption_ClosureReasonZ.Some)raw_val);
+ }
+ if (raw_val.getClass() == bindings.LDKCOption_ClosureReasonZ.None.class) {
+ return new None(ptr, (bindings.LDKCOption_ClosureReasonZ.None)raw_val);
+ }
+ assert false; return null; // Unreachable without extending the (internal) bindings interface
+ }
+
+ /**
+ * When we're in this state, this COption_ClosureReasonZ contains a crate::lightning::util::events::ClosureReason
+ */
+ public final static class Some extends Option_ClosureReasonZ {
+ public final ClosureReason some;
+ private Some(long ptr, bindings.LDKCOption_ClosureReasonZ.Some obj) {
+ super(null, ptr);
+ long some = obj.some;
+ ClosureReason some_hu_conv = ClosureReason.constr_from_ptr(some);
+ some_hu_conv.ptrs_to.add(this);
+ this.some = some_hu_conv;
+ }
+ }
+ /**
+ * When we're in this state, this COption_ClosureReasonZ contains nothing
+ */
+ public final static class None extends Option_ClosureReasonZ {
+ private None(long ptr, bindings.LDKCOption_ClosureReasonZ.None obj) {
+ super(null, ptr);
+ }
+ }
+ /**
+ * Constructs a new COption_ClosureReasonZ containing a crate::lightning::util::events::ClosureReason
+ */
+ public static Option_ClosureReasonZ some(ClosureReason o) {
+ long ret = bindings.COption_ClosureReasonZ_some(o.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Option_ClosureReasonZ ret_hu_conv = Option_ClosureReasonZ.constr_from_ptr(ret);
+ ret_hu_conv.ptrs_to.add(ret_hu_conv);
+ return ret_hu_conv;
+ }
+
+ /**
+ * Constructs a new COption_ClosureReasonZ containing nothing
+ */
+ public static Option_ClosureReasonZ none() {
+ long ret = bindings.COption_ClosureReasonZ_none();
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Option_ClosureReasonZ ret_hu_conv = Option_ClosureReasonZ.constr_from_ptr(ret);
+ ret_hu_conv.ptrs_to.add(ret_hu_conv);
+ return ret_hu_conv;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.COption_ClosureReasonZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
+ /**
+ * Creates a new COption_ClosureReasonZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
+ */
+ public Option_ClosureReasonZ clone() {
+ long ret = bindings.COption_ClosureReasonZ_clone(this.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Option_ClosureReasonZ ret_hu_conv = Option_ClosureReasonZ.constr_from_ptr(ret);
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+}
--- /dev/null
+package org.ldk.structs;
+
+import org.ldk.impl.bindings;
+import org.ldk.enums.*;
+import org.ldk.util.*;
+import java.util.Arrays;
+import javax.annotation.Nullable;
+
+
+/**
+ * An enum which can either contain a crate::lightning::util::events::Event or not
+ */
+@SuppressWarnings("unchecked") // We correctly assign various generic arrays
+public class Option_EventZ extends CommonBase {
+ private Option_EventZ(Object _dummy, long ptr) { super(ptr); }
+ @Override @SuppressWarnings("deprecation")
+ protected void finalize() throws Throwable {
+ super.finalize();
+ if (ptr != 0) { bindings.COption_EventZ_free(ptr); }
+ }
+ static Option_EventZ constr_from_ptr(long ptr) {
+ bindings.LDKCOption_EventZ raw_val = bindings.LDKCOption_EventZ_ref_from_ptr(ptr);
+ if (raw_val.getClass() == bindings.LDKCOption_EventZ.Some.class) {
+ return new Some(ptr, (bindings.LDKCOption_EventZ.Some)raw_val);
+ }
+ if (raw_val.getClass() == bindings.LDKCOption_EventZ.None.class) {
+ return new None(ptr, (bindings.LDKCOption_EventZ.None)raw_val);
+ }
+ assert false; return null; // Unreachable without extending the (internal) bindings interface
+ }
+
+ /**
+ * When we're in this state, this COption_EventZ contains a crate::lightning::util::events::Event
+ */
+ public final static class Some extends Option_EventZ {
+ public final Event some;
+ private Some(long ptr, bindings.LDKCOption_EventZ.Some obj) {
+ super(null, ptr);
+ long some = obj.some;
+ Event some_hu_conv = Event.constr_from_ptr(some);
+ some_hu_conv.ptrs_to.add(this);
+ this.some = some_hu_conv;
+ }
+ }
+ /**
+ * When we're in this state, this COption_EventZ contains nothing
+ */
+ public final static class None extends Option_EventZ {
+ private None(long ptr, bindings.LDKCOption_EventZ.None obj) {
+ super(null, ptr);
+ }
+ }
+ /**
+ * Constructs a new COption_EventZ containing a crate::lightning::util::events::Event
+ */
+ public static Option_EventZ some(Event o) {
+ long ret = bindings.COption_EventZ_some(o.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Option_EventZ ret_hu_conv = Option_EventZ.constr_from_ptr(ret);
+ ret_hu_conv.ptrs_to.add(ret_hu_conv);
+ return ret_hu_conv;
+ }
+
+ /**
+ * Constructs a new COption_EventZ containing nothing
+ */
+ public static Option_EventZ none() {
+ long ret = bindings.COption_EventZ_none();
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Option_EventZ ret_hu_conv = Option_EventZ.constr_from_ptr(ret);
+ ret_hu_conv.ptrs_to.add(ret_hu_conv);
+ return ret_hu_conv;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.COption_EventZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
+ /**
+ * Creates a new COption_EventZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
+ */
+ public Option_EventZ clone() {
+ long ret = bindings.COption_EventZ_clone(this.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Option_EventZ ret_hu_conv = Option_EventZ.constr_from_ptr(ret);
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+}
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * When we're in this state, this COption_FilterZ contains a crate::lightning::chain::Filter
+ */
public final static class Some extends Option_FilterZ {
public final Filter some;
private Some(long ptr, bindings.LDKCOption_FilterZ.Some obj) {
this.some = ret_hu_conv;
}
}
+ /**
+ * When we're in this state, this COption_FilterZ contains nothing
+ */
public final static class None extends Option_FilterZ {
private None(long ptr, bindings.LDKCOption_FilterZ.None obj) {
super(null, ptr);
--- /dev/null
+package org.ldk.structs;
+
+import org.ldk.impl.bindings;
+import org.ldk.enums.*;
+import org.ldk.util.*;
+import java.util.Arrays;
+import javax.annotation.Nullable;
+
+
+/**
+ * An enum which can either contain a crate::lightning::chain::channelmonitor::MonitorEvent or not
+ */
+@SuppressWarnings("unchecked") // We correctly assign various generic arrays
+public class Option_MonitorEventZ extends CommonBase {
+ private Option_MonitorEventZ(Object _dummy, long ptr) { super(ptr); }
+ @Override @SuppressWarnings("deprecation")
+ protected void finalize() throws Throwable {
+ super.finalize();
+ if (ptr != 0) { bindings.COption_MonitorEventZ_free(ptr); }
+ }
+ static Option_MonitorEventZ constr_from_ptr(long ptr) {
+ bindings.LDKCOption_MonitorEventZ raw_val = bindings.LDKCOption_MonitorEventZ_ref_from_ptr(ptr);
+ if (raw_val.getClass() == bindings.LDKCOption_MonitorEventZ.Some.class) {
+ return new Some(ptr, (bindings.LDKCOption_MonitorEventZ.Some)raw_val);
+ }
+ if (raw_val.getClass() == bindings.LDKCOption_MonitorEventZ.None.class) {
+ return new None(ptr, (bindings.LDKCOption_MonitorEventZ.None)raw_val);
+ }
+ assert false; return null; // Unreachable without extending the (internal) bindings interface
+ }
+
+ /**
+ * When we're in this state, this COption_MonitorEventZ contains a crate::lightning::chain::channelmonitor::MonitorEvent
+ */
+ public final static class Some extends Option_MonitorEventZ {
+ public final MonitorEvent some;
+ private Some(long ptr, bindings.LDKCOption_MonitorEventZ.Some obj) {
+ super(null, ptr);
+ long some = obj.some;
+ MonitorEvent some_hu_conv = MonitorEvent.constr_from_ptr(some);
+ some_hu_conv.ptrs_to.add(this);
+ this.some = some_hu_conv;
+ }
+ }
+ /**
+ * When we're in this state, this COption_MonitorEventZ contains nothing
+ */
+ public final static class None extends Option_MonitorEventZ {
+ private None(long ptr, bindings.LDKCOption_MonitorEventZ.None obj) {
+ super(null, ptr);
+ }
+ }
+ /**
+ * Constructs a new COption_MonitorEventZ containing a crate::lightning::chain::channelmonitor::MonitorEvent
+ */
+ public static Option_MonitorEventZ some(MonitorEvent o) {
+ long ret = bindings.COption_MonitorEventZ_some(o.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Option_MonitorEventZ ret_hu_conv = Option_MonitorEventZ.constr_from_ptr(ret);
+ ret_hu_conv.ptrs_to.add(ret_hu_conv);
+ return ret_hu_conv;
+ }
+
+ /**
+ * Constructs a new COption_MonitorEventZ containing nothing
+ */
+ public static Option_MonitorEventZ none() {
+ long ret = bindings.COption_MonitorEventZ_none();
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Option_MonitorEventZ ret_hu_conv = Option_MonitorEventZ.constr_from_ptr(ret);
+ ret_hu_conv.ptrs_to.add(ret_hu_conv);
+ return ret_hu_conv;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.COption_MonitorEventZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
+ /**
+ * Creates a new COption_MonitorEventZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
+ */
+ public Option_MonitorEventZ clone() {
+ long ret = bindings.COption_MonitorEventZ_clone(this.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Option_MonitorEventZ ret_hu_conv = Option_MonitorEventZ.constr_from_ptr(ret);
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+}
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * When we're in this state, this COption_NetworkUpdateZ contains a crate::lightning::routing::network_graph::NetworkUpdate
+ */
public final static class Some extends Option_NetworkUpdateZ {
public final NetworkUpdate some;
private Some(long ptr, bindings.LDKCOption_NetworkUpdateZ.Some obj) {
this.some = some_hu_conv;
}
}
+ /**
+ * When we're in this state, this COption_NetworkUpdateZ contains nothing
+ */
public final static class None extends Option_NetworkUpdateZ {
private None(long ptr, bindings.LDKCOption_NetworkUpdateZ.None obj) {
super(null, ptr);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.COption_NetworkUpdateZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new COption_NetworkUpdateZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * When we're in this state, this COption_TypeZ contains a crate::lightning::ln::wire::Type
+ */
public final static class Some extends Option_TypeZ {
public final Type some;
private Some(long ptr, bindings.LDKCOption_TypeZ.Some obj) {
this.some = ret_hu_conv;
}
}
+ /**
+ * When we're in this state, this COption_TypeZ contains nothing
+ */
public final static class None extends Option_TypeZ {
private None(long ptr, bindings.LDKCOption_TypeZ.None obj) {
super(null, ptr);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.COption_TypeZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new COption_TypeZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * When we're in this state, this COption_u16Z contains a u16
+ */
public final static class Some extends Option_u16Z {
public final short some;
private Some(long ptr, bindings.LDKCOption_u16Z.Some obj) {
this.some = obj.some;
}
}
+ /**
+ * When we're in this state, this COption_u16Z contains nothing
+ */
public final static class None extends Option_u16Z {
private None(long ptr, bindings.LDKCOption_u16Z.None obj) {
super(null, ptr);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.COption_u16Z_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new COption_u16Z which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * When we're in this state, this COption_u32Z contains a u32
+ */
public final static class Some extends Option_u32Z {
public final int some;
private Some(long ptr, bindings.LDKCOption_u32Z.Some obj) {
this.some = obj.some;
}
}
+ /**
+ * When we're in this state, this COption_u32Z contains nothing
+ */
public final static class None extends Option_u32Z {
private None(long ptr, bindings.LDKCOption_u32Z.None obj) {
super(null, ptr);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.COption_u32Z_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new COption_u32Z which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * When we're in this state, this COption_u64Z contains a u64
+ */
public final static class Some extends Option_u64Z {
public final long some;
private Some(long ptr, bindings.LDKCOption_u64Z.Some obj) {
this.some = obj.some;
}
}
+ /**
+ * When we're in this state, this COption_u64Z contains nothing
+ */
public final static class None extends Option_u64Z {
private None(long ptr, bindings.LDKCOption_u64Z.None obj) {
super(null, ptr);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.COption_u64Z_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new COption_u64Z which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
* The referenced transaction's txid.
*/
public void set_txid(byte[] val) {
- bindings.OutPoint_set_txid(this.ptr, val);
+ bindings.OutPoint_set_txid(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* Constructs a new OutPoint given each field
*/
public static OutPoint of(byte[] txid_arg, short index_arg) {
- long ret = bindings.OutPoint_new(txid_arg, index_arg);
+ long ret = bindings.OutPoint_new(InternalUtils.check_arr_len(txid_arg, 32), index_arg);
if (ret >= 0 && ret <= 4096) { return null; }
OutPoint ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new OutPoint(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.OutPoint_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the OutPoint
*/
* The node id of the payee.
*/
public void set_pubkey(byte[] val) {
- bindings.Payee_set_pubkey(this.ptr, val);
+ bindings.Payee_set_pubkey(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* Constructs a new Payee given each field
*/
public static Payee of(byte[] pubkey_arg, InvoiceFeatures features_arg, RouteHint[] route_hints_arg, Option_u64Z expiry_time_arg) {
- long ret = bindings.Payee_new(pubkey_arg, features_arg == null ? 0 : features_arg.ptr & ~1, route_hints_arg != null ? Arrays.stream(route_hints_arg).mapToLong(route_hints_arg_conv_11 -> route_hints_arg_conv_11 == null ? 0 : route_hints_arg_conv_11.ptr & ~1).toArray() : null, expiry_time_arg.ptr);
+ long ret = bindings.Payee_new(InternalUtils.check_arr_len(pubkey_arg, 33), features_arg == null ? 0 : features_arg.ptr & ~1, route_hints_arg != null ? Arrays.stream(route_hints_arg).mapToLong(route_hints_arg_conv_11 -> route_hints_arg_conv_11 == null ? 0 : route_hints_arg_conv_11.ptr & ~1).toArray() : null, expiry_time_arg.ptr);
if (ret >= 0 && ret <= 4096) { return null; }
Payee ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new Payee(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.Payee_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the Payee
*/
* Creates a payee with the node id of the given `pubkey`.
*/
public static Payee from_node_id(byte[] pubkey) {
- long ret = bindings.Payee_from_node_id(pubkey);
+ long ret = bindings.Payee_from_node_id(InternalUtils.check_arr_len(pubkey, 33));
if (ret >= 0 && ret <= 4096) { return null; }
Payee ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new Payee(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Creates a payee with the node id of the given `pubkey` to use for keysend payments.
*/
public static Payee for_keysend(byte[] pubkey) {
- long ret = bindings.Payee_for_keysend(pubkey);
+ long ret = bindings.Payee_for_keysend(InternalUtils.check_arr_len(pubkey, 33));
if (ret >= 0 && ret <= 4096) { return null; }
Payee ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new Payee(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
}
public void set_a(byte[] val) {
- bindings.PayeePubKey_set_a(this.ptr, val);
+ bindings.PayeePubKey_set_a(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* Constructs a new PayeePubKey given each field
*/
public static PayeePubKey of(byte[] a_arg) {
- long ret = bindings.PayeePubKey_new(a_arg);
+ long ret = bindings.PayeePubKey_new(InternalUtils.check_arr_len(a_arg, 33));
if (ret >= 0 && ret <= 4096) { return null; }
PayeePubKey ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new PayeePubKey(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.PayeePubKey_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the PayeePubKey
*/
impl_holder.held = new Payer(new bindings.LDKPayer() {
@Override public byte[] node_id() {
byte[] ret = arg.node_id();
- return ret;
+ byte[] result = InternalUtils.check_arr_len(ret, 33);
+ return result;
}
@Override public long[] first_hops() {
ChannelDetails[] ret = arg.first_hops();
- long[] result = ret != null ? Arrays.stream(ret).mapToLong(ret_conv_16 -> ret_conv_16 == null ? 0 : ret_conv_16.ptr & ~1).toArray() : null;
+ long[] result = ret != null ? Arrays.stream(ret).mapToLong(ret_conv_16 -> ret_conv_16 == null ? 0 : ret_conv_16.clone_ptr()).toArray() : null;
return result;
}
@Override public long send_payment(long route, byte[] payment_hash, byte[] payment_secret) {
Route route_hu_conv = null; if (route < 0 || route > 4096) { route_hu_conv = new Route(null, route); }
Result_PaymentIdPaymentSendFailureZ ret = arg.send_payment(route_hu_conv, payment_hash, payment_secret);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
@Override public long retry_payment(long route, byte[] payment_id) {
Route route_hu_conv = null; if (route < 0 || route > 4096) { route_hu_conv = new Route(null, route); }
Result_NonePaymentSendFailureZ ret = arg.retry_payment(route_hu_conv, payment_id);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
});
* Note that payment_secret (or a relevant inner pointer) may be NULL or all-0s to represent None
*/
public Result_PaymentIdPaymentSendFailureZ send_payment(Route route, byte[] payment_hash, @Nullable byte[] payment_secret) {
- long ret = bindings.Payer_send_payment(this.ptr, route == null ? 0 : route.ptr & ~1, payment_hash, payment_secret);
+ long ret = bindings.Payer_send_payment(this.ptr, route == null ? 0 : route.ptr & ~1, InternalUtils.check_arr_len(payment_hash, 32), InternalUtils.check_arr_len(payment_secret, 32));
if (ret >= 0 && ret <= 4096) { return null; }
Result_PaymentIdPaymentSendFailureZ ret_hu_conv = Result_PaymentIdPaymentSendFailureZ.constr_from_ptr(ret);
this.ptrs_to.add(route);
* Retries a failed payment path for the [`PaymentId`] using the given [`Route`].
*/
public Result_NonePaymentSendFailureZ retry_payment(Route route, byte[] payment_id) {
- long ret = bindings.Payer_retry_payment(this.ptr, route == null ? 0 : route.ptr & ~1, payment_id);
+ long ret = bindings.Payer_retry_payment(this.ptr, route == null ? 0 : route.ptr & ~1, InternalUtils.check_arr_len(payment_id, 32));
if (ret >= 0 && ret <= 4096) { return null; }
Result_NonePaymentSendFailureZ ret_hu_conv = Result_NonePaymentSendFailureZ.constr_from_ptr(ret);
this.ptrs_to.add(route);
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * An error resulting from the provided [`Invoice`] or payment hash.
+ */
public final static class Invoice extends PaymentError {
public final String invoice;
private Invoice(long ptr, bindings.LDKPaymentError.Invoice obj) {
this.invoice = obj.invoice;
}
}
+ /**
+ * An error occurring when finding a route.
+ */
public final static class Routing extends PaymentError {
public final LightningError routing;
private Routing(long ptr, bindings.LDKPaymentError.Routing obj) {
this.routing = routing_hu_conv;
}
}
+ /**
+ * An error occurring when sending a payment.
+ */
public final static class Sending extends PaymentError {
public final PaymentSendFailure sending;
private Sending(long ptr, bindings.LDKPaymentError.Sending obj) {
this.sending = sending_hu_conv;
}
}
+ long clone_ptr() {
+ long ret = bindings.PaymentError_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the PaymentError
*/
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * Information for receiving a payment that we generated an invoice for.
+ */
public final static class InvoicePayment extends PaymentPurpose {
/**
* The preimage to the payment_hash, if the payment hash (and secret) were fetched via
this.user_payment_id = obj.user_payment_id;
}
}
+ /**
+ * Because this is a spontaneous payment, the payer generated their own preimage rather than us
+ * (the payee) providing a preimage.
+ */
public final static class SpontaneousPayment extends PaymentPurpose {
public final byte[] spontaneous_payment;
private SpontaneousPayment(long ptr, bindings.LDKPaymentPurpose.SpontaneousPayment obj) {
this.spontaneous_payment = obj.spontaneous_payment;
}
}
+ long clone_ptr() {
+ long ret = bindings.PaymentPurpose_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the PaymentPurpose
*/
* Utility method to constructs a new InvoicePayment-variant PaymentPurpose
*/
public static PaymentPurpose invoice_payment(byte[] payment_preimage, byte[] payment_secret, long user_payment_id) {
- long ret = bindings.PaymentPurpose_invoice_payment(payment_preimage, payment_secret, user_payment_id);
+ long ret = bindings.PaymentPurpose_invoice_payment(InternalUtils.check_arr_len(payment_preimage, 32), InternalUtils.check_arr_len(payment_secret, 32), user_payment_id);
if (ret >= 0 && ret <= 4096) { return null; }
PaymentPurpose ret_hu_conv = PaymentPurpose.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Utility method to constructs a new SpontaneousPayment-variant PaymentPurpose
*/
public static PaymentPurpose spontaneous_payment(byte[] a) {
- long ret = bindings.PaymentPurpose_spontaneous_payment(a);
+ long ret = bindings.PaymentPurpose_spontaneous_payment(InternalUtils.check_arr_len(a, 32));
if (ret >= 0 && ret <= 4096) { return null; }
PaymentPurpose ret_hu_conv = PaymentPurpose.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * A parameter which was passed to send_payment was invalid, preventing us from attempting to
+ * send the payment at all. No channel state has been changed or messages sent to peers, and
+ * once you've changed the parameter at error, you can freely retry the payment in full.
+ */
public final static class ParameterError extends PaymentSendFailure {
public final APIError parameter_error;
private ParameterError(long ptr, bindings.LDKPaymentSendFailure.ParameterError obj) {
this.parameter_error = parameter_error_hu_conv;
}
}
+ /**
+ * A parameter in a single path which was passed to send_payment was invalid, preventing us
+ * from attempting to send the payment at all. No channel state has been changed or messages
+ * sent to peers, and once you've changed the parameter at error, you can freely retry the
+ * payment in full.
+ *
+ * The results here are ordered the same as the paths in the route object which was passed to
+ * send_payment.
+ */
public final static class PathParameterError extends PaymentSendFailure {
public final Result_NoneAPIErrorZ[] path_parameter_error;
private PathParameterError(long ptr, bindings.LDKPaymentSendFailure.PathParameterError obj) {
this.path_parameter_error = path_parameter_error_conv_22_arr;
}
}
+ /**
+ * All paths which were attempted failed to send, with no channel state change taking place.
+ * You can freely retry the payment in full (though you probably want to do so over different
+ * paths than the ones selected).
+ */
public final static class AllFailedRetrySafe extends PaymentSendFailure {
public final APIError[] all_failed_retry_safe;
private AllFailedRetrySafe(long ptr, bindings.LDKPaymentSendFailure.AllFailedRetrySafe obj) {
this.all_failed_retry_safe = all_failed_retry_safe_conv_10_arr;
}
}
+ /**
+ * Some paths which were attempted failed to send, though possibly not all. At least some
+ * paths have irrevocably committed to the HTLC and retrying the payment in full would result
+ * in over-/re-payment.
+ *
+ * The results here are ordered the same as the paths in the route object which was passed to
+ * send_payment, and any Errs which are not APIError::MonitorUpdateFailed can be safely
+ * retried (though there is currently no API with which to do so).
+ *
+ * Any entries which contain Err(APIError::MonitorUpdateFailed) or Ok(()) MUST NOT be retried
+ * as they will result in over-/re-payment. These HTLCs all either successfully sent (in the
+ * case of Ok(())) or will send once channel_monitor_updated is called on the next-hop channel
+ * with the latest update_id.
+ */
public final static class PartialFailure extends PaymentSendFailure {
/**
* The errors themselves, in the same order as the route hops.
this.payment_id = obj.payment_id;
}
}
+ long clone_ptr() {
+ long ret = bindings.PaymentSendFailure_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the PaymentSendFailure
*/
* Utility method to constructs a new PartialFailure-variant PaymentSendFailure
*/
public static PaymentSendFailure partial_failure(Result_NoneAPIErrorZ[] results, RouteParameters failed_paths_retry, byte[] payment_id) {
- long ret = bindings.PaymentSendFailure_partial_failure(results != null ? Arrays.stream(results).mapToLong(results_conv_22 -> results_conv_22 != null ? results_conv_22.ptr : 0).toArray() : null, failed_paths_retry == null ? 0 : failed_paths_retry.ptr & ~1, payment_id);
+ long ret = bindings.PaymentSendFailure_partial_failure(results != null ? Arrays.stream(results).mapToLong(results_conv_22 -> results_conv_22 != null ? results_conv_22.ptr : 0).toArray() : null, failed_paths_retry == null ? 0 : failed_paths_retry.ptr & ~1, InternalUtils.check_arr_len(payment_id, 32));
if (ret >= 0 && ret <= 4096) { return null; }
PaymentSendFailure ret_hu_conv = PaymentSendFailure.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.PeerHandleError_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the PeerHandleError
*/
* cryptographically secure random bytes.
*/
public static PeerManager of(ChannelMessageHandler message_handler_chan_handler_arg, RoutingMessageHandler message_handler_route_handler_arg, byte[] our_node_secret, byte[] ephemeral_random_data, Logger logger, CustomMessageHandler custom_message_handler) {
- long ret = bindings.PeerManager_new(bindings.MessageHandler_new(message_handler_chan_handler_arg == null ? 0 : message_handler_chan_handler_arg.ptr, message_handler_route_handler_arg == null ? 0 : message_handler_route_handler_arg.ptr), our_node_secret, ephemeral_random_data, logger == null ? 0 : logger.ptr, custom_message_handler == null ? 0 : custom_message_handler.ptr);
+ long ret = bindings.PeerManager_new(bindings.MessageHandler_new(message_handler_chan_handler_arg == null ? 0 : message_handler_chan_handler_arg.ptr, message_handler_route_handler_arg == null ? 0 : message_handler_route_handler_arg.ptr), InternalUtils.check_arr_len(our_node_secret, 32), InternalUtils.check_arr_len(ephemeral_random_data, 32), logger == null ? 0 : logger.ptr, custom_message_handler == null ? 0 : custom_message_handler.ptr);
if (ret >= 0 && ret <= 4096) { return null; }
PeerManager ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new PeerManager(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* [`socket_disconnected()`]: PeerManager::socket_disconnected
*/
public Result_CVec_u8ZPeerHandleErrorZ new_outbound_connection(byte[] their_node_id, SocketDescriptor descriptor) {
- long ret = bindings.PeerManager_new_outbound_connection(this.ptr, their_node_id, descriptor == null ? 0 : descriptor.ptr);
+ long ret = bindings.PeerManager_new_outbound_connection(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), descriptor == null ? 0 : descriptor.ptr);
if (ret >= 0 && ret <= 4096) { return null; }
Result_CVec_u8ZPeerHandleErrorZ ret_hu_conv = Result_CVec_u8ZPeerHandleErrorZ.constr_from_ptr(ret);
this.ptrs_to.add(descriptor);
* [`disconnect_socket`]: SocketDescriptor::disconnect_socket
*/
public void disconnect_by_node_id(byte[] node_id, boolean no_connection_possible) {
- bindings.PeerManager_disconnect_by_node_id(this.ptr, node_id, no_connection_possible);
+ bindings.PeerManager_disconnect_by_node_id(this.ptr, InternalUtils.check_arr_len(node_id, 33), no_connection_possible);
}
/**
MonitorUpdateId update_id_hu_conv = null; if (update_id < 0 || update_id > 4096) { update_id_hu_conv = new MonitorUpdateId(null, update_id); }
update_id_hu_conv.ptrs_to.add(this);
Result_NoneChannelMonitorUpdateErrZ ret = arg.persist_new_channel(channel_id_hu_conv, data_hu_conv, update_id_hu_conv);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
@Override public long update_persisted_channel(long channel_id, long update, long data, long update_id) {
MonitorUpdateId update_id_hu_conv = null; if (update_id < 0 || update_id > 4096) { update_id_hu_conv = new MonitorUpdateId(null, update_id); }
update_id_hu_conv.ptrs_to.add(this);
Result_NoneChannelMonitorUpdateErrZ ret = arg.update_persisted_channel(channel_id_hu_conv, update_hu_conv, data_hu_conv, update_id_hu_conv);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
});
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.Ping_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the Ping
*/
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.Pong_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the Pong
*/
return ret;
}
+ long clone_ptr() {
+ long ret = bindings.PositiveTimestamp_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the PositiveTimestamp
*/
if (ptr != 0) { bindings.PrivateRoute_free(ptr); }
}
+ long clone_ptr() {
+ long ret = bindings.PrivateRoute_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the PrivateRoute
*/
* The genesis hash of the blockchain being queried
*/
public void set_chain_hash(byte[] val) {
- bindings.QueryChannelRange_set_chain_hash(this.ptr, val);
+ bindings.QueryChannelRange_set_chain_hash(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* Constructs a new QueryChannelRange given each field
*/
public static QueryChannelRange of(byte[] chain_hash_arg, int first_blocknum_arg, int number_of_blocks_arg) {
- long ret = bindings.QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
+ long ret = bindings.QueryChannelRange_new(InternalUtils.check_arr_len(chain_hash_arg, 32), first_blocknum_arg, number_of_blocks_arg);
if (ret >= 0 && ret <= 4096) { return null; }
QueryChannelRange ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new QueryChannelRange(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.QueryChannelRange_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the QueryChannelRange
*/
* The genesis hash of the blockchain being queried
*/
public void set_chain_hash(byte[] val) {
- bindings.QueryShortChannelIds_set_chain_hash(this.ptr, val);
+ bindings.QueryShortChannelIds_set_chain_hash(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* Constructs a new QueryShortChannelIds given each field
*/
public static QueryShortChannelIds of(byte[] chain_hash_arg, long[] short_channel_ids_arg) {
- long ret = bindings.QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
+ long ret = bindings.QueryShortChannelIds_new(InternalUtils.check_arr_len(chain_hash_arg, 32), short_channel_ids_arg);
if (ret >= 0 && ret <= 4096) { return null; }
QueryShortChannelIds ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new QueryShortChannelIds(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.QueryShortChannelIds_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the QueryShortChannelIds
*/
return ret;
}
+ long clone_ptr() {
+ long ret = bindings.RawDataPart_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the RawDataPart
*/
return ret;
}
+ long clone_ptr() {
+ long ret = bindings.RawInvoice_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the RawInvoice
*/
* or if node announcement for the node was never received.
*/
public Option_CVec_NetAddressZZ get_addresses(byte[] pubkey) {
- long ret = bindings.ReadOnlyNetworkGraph_get_addresses(this.ptr, pubkey);
+ long ret = bindings.ReadOnlyNetworkGraph_get_addresses(this.ptr, InternalUtils.check_arr_len(pubkey, 33));
if (ret >= 0 && ret <= 4096) { return null; }
Option_CVec_NetAddressZZ ret_hu_conv = Option_CVec_NetAddressZZ.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(this);
--- /dev/null
+package org.ldk.structs;
+
+import org.ldk.impl.bindings;
+import org.ldk.enums.*;
+import org.ldk.util.*;
+import java.util.Arrays;
+import javax.annotation.Nullable;
+
+
+/**
+ * A Record, unit of logging output with Metadata to enable filtering
+ * Module_path, file, line to inform on log's source
+ */
+@SuppressWarnings("unchecked") // We correctly assign various generic arrays
+public class Record extends CommonBase {
+ Record(Object _dummy, long ptr) { super(ptr); }
+ @Override @SuppressWarnings("deprecation")
+ protected void finalize() throws Throwable {
+ super.finalize();
+ if (ptr != 0) { bindings.Record_free(ptr); }
+ }
+
+ /**
+ * The verbosity level of the message.
+ */
+ public Level get_level() {
+ Level ret = bindings.Record_get_level(this.ptr);
+ return ret;
+ }
+
+ /**
+ * The verbosity level of the message.
+ */
+ public void set_level(org.ldk.enums.Level val) {
+ bindings.Record_set_level(this.ptr, val);
+ }
+
+ /**
+ * The message body.
+ */
+ public String get_args() {
+ String ret = bindings.Record_get_args(this.ptr);
+ return ret;
+ }
+
+ /**
+ * The message body.
+ */
+ public void set_args(java.lang.String val) {
+ bindings.Record_set_args(this.ptr, val);
+ }
+
+ /**
+ * The module path of the message.
+ */
+ public String get_module_path() {
+ String ret = bindings.Record_get_module_path(this.ptr);
+ return ret;
+ }
+
+ /**
+ * The module path of the message.
+ */
+ public void set_module_path(java.lang.String val) {
+ bindings.Record_set_module_path(this.ptr, val);
+ }
+
+ /**
+ * The source file containing the message.
+ */
+ public String get_file() {
+ String ret = bindings.Record_get_file(this.ptr);
+ return ret;
+ }
+
+ /**
+ * The source file containing the message.
+ */
+ public void set_file(java.lang.String val) {
+ bindings.Record_set_file(this.ptr, val);
+ }
+
+ /**
+ * The line containing the message.
+ */
+ public int get_line() {
+ int ret = bindings.Record_get_line(this.ptr);
+ return ret;
+ }
+
+ /**
+ * The line containing the message.
+ */
+ public void set_line(int val) {
+ bindings.Record_set_line(this.ptr, val);
+ }
+
+ long clone_ptr() {
+ long ret = bindings.Record_clone_ptr(this.ptr);
+ return ret;
+ }
+
+ /**
+ * Creates a copy of the Record
+ */
+ public Record clone() {
+ long ret = bindings.Record_clone(this.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Record ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new Record(null, ret); }
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+}
* The genesis hash of the blockchain being queried
*/
public void set_chain_hash(byte[] val) {
- bindings.ReplyChannelRange_set_chain_hash(this.ptr, val);
+ bindings.ReplyChannelRange_set_chain_hash(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* Constructs a new ReplyChannelRange given each field
*/
public static ReplyChannelRange of(byte[] chain_hash_arg, int first_blocknum_arg, int number_of_blocks_arg, boolean sync_complete_arg, long[] short_channel_ids_arg) {
- long ret = bindings.ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
+ long ret = bindings.ReplyChannelRange_new(InternalUtils.check_arr_len(chain_hash_arg, 32), first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
if (ret >= 0 && ret <= 4096) { return null; }
ReplyChannelRange ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new ReplyChannelRange(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.ReplyChannelRange_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ReplyChannelRange
*/
* The genesis hash of the blockchain that was queried
*/
public void set_chain_hash(byte[] val) {
- bindings.ReplyShortChannelIdsEnd_set_chain_hash(this.ptr, val);
+ bindings.ReplyShortChannelIdsEnd_set_chain_hash(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* Constructs a new ReplyShortChannelIdsEnd given each field
*/
public static ReplyShortChannelIdsEnd of(byte[] chain_hash_arg, boolean full_information_arg) {
- long ret = bindings.ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
+ long ret = bindings.ReplyShortChannelIdsEnd_new(InternalUtils.check_arr_len(chain_hash_arg, 32), full_information_arg);
if (ret >= 0 && ret <= 4096) { return null; }
ReplyShortChannelIdsEnd ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new ReplyShortChannelIdsEnd(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.ReplyShortChannelIdsEnd_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ReplyShortChannelIdsEnd
*/
}
static Result_AcceptChannelDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_AcceptChannelDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_AcceptChannelDecodeErrorZ_is_ok(ptr)) {
return new Result_AcceptChannelDecodeErrorZ_OK(null, ptr);
} else {
return new Result_AcceptChannelDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_AcceptChannelDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_AcceptChannelDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_AcceptChannelDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_AnnouncementSignaturesDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_AnnouncementSignaturesDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(ptr)) {
return new Result_AnnouncementSignaturesDecodeErrorZ_OK(null, ptr);
} else {
return new Result_AnnouncementSignaturesDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_AnnouncementSignaturesDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_BuiltCommitmentTransactionDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_BuiltCommitmentTransactionDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(ptr)) {
return new Result_BuiltCommitmentTransactionDecodeErrorZ_OK(null, ptr);
} else {
return new Result_BuiltCommitmentTransactionDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_BuiltCommitmentTransactionDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(ptr)) {
return new Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_OK(null, ptr);
} else {
return new Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
}
}
static Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(ptr)) {
return new Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_OK(null, ptr);
} else {
return new Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_result_ok(ptr)) {
+ if (bindings.CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(ptr)) {
return new Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_OK(null, ptr);
} else {
return new Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_C2Tuple_SignatureCVec_SignatureZZNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(ptr)) {
return new Result_C2Tuple_SignatureCVec_SignatureZZNoneZ_OK(null, ptr);
} else {
return new Result_C2Tuple_SignatureCVec_SignatureZZNoneZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
--- /dev/null
+package org.ldk.structs;
+
+import org.ldk.impl.bindings;
+import org.ldk.enums.*;
+import org.ldk.util.*;
+import java.util.Arrays;
+import javax.annotation.Nullable;
+
+public class Result_COption_ClosureReasonZDecodeErrorZ extends CommonBase {
+ private Result_COption_ClosureReasonZDecodeErrorZ(Object _dummy, long ptr) { super(ptr); }
+ protected void finalize() throws Throwable {
+ if (ptr != 0) { bindings.CResult_COption_ClosureReasonZDecodeErrorZ_free(ptr); } super.finalize();
+ }
+
+ static Result_COption_ClosureReasonZDecodeErrorZ constr_from_ptr(long ptr) {
+ if (bindings.CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(ptr)) {
+ return new Result_COption_ClosureReasonZDecodeErrorZ_OK(null, ptr);
+ } else {
+ return new Result_COption_ClosureReasonZDecodeErrorZ_Err(null, ptr);
+ }
+ }
+ public static final class Result_COption_ClosureReasonZDecodeErrorZ_OK extends Result_COption_ClosureReasonZDecodeErrorZ {
+ public final Option_ClosureReasonZ res;
+ private Result_COption_ClosureReasonZDecodeErrorZ_OK(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ long res = bindings.LDKCResult_COption_ClosureReasonZDecodeErrorZ_get_ok(ptr);
+ Option_ClosureReasonZ res_hu_conv = Option_ClosureReasonZ.constr_from_ptr(res);
+ res_hu_conv.ptrs_to.add(this);
+ this.res = res_hu_conv;
+ }
+ }
+
+ public static final class Result_COption_ClosureReasonZDecodeErrorZ_Err extends Result_COption_ClosureReasonZDecodeErrorZ {
+ public final DecodeError err;
+ private Result_COption_ClosureReasonZDecodeErrorZ_Err(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ long err = bindings.LDKCResult_COption_ClosureReasonZDecodeErrorZ_get_err(ptr);
+ DecodeError err_hu_conv = null; if (err < 0 || err > 4096) { err_hu_conv = new DecodeError(null, err); }
+ err_hu_conv.ptrs_to.add(this);
+ this.err = err_hu_conv;
+ }
+ }
+
+ /**
+ * Creates a new CResult_COption_ClosureReasonZDecodeErrorZ in the success state.
+ */
+ public static Result_COption_ClosureReasonZDecodeErrorZ ok(Option_ClosureReasonZ o) {
+ long ret = bindings.CResult_COption_ClosureReasonZDecodeErrorZ_ok(o.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Result_COption_ClosureReasonZDecodeErrorZ ret_hu_conv = Result_COption_ClosureReasonZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ /**
+ * Creates a new CResult_COption_ClosureReasonZDecodeErrorZ in the error state.
+ */
+ public static Result_COption_ClosureReasonZDecodeErrorZ err(DecodeError e) {
+ long ret = bindings.CResult_COption_ClosureReasonZDecodeErrorZ_err(e == null ? 0 : e.ptr & ~1);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Result_COption_ClosureReasonZDecodeErrorZ ret_hu_conv = Result_COption_ClosureReasonZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
+ /**
+ * Creates a new CResult_COption_ClosureReasonZDecodeErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
+ */
+ public Result_COption_ClosureReasonZDecodeErrorZ clone() {
+ long ret = bindings.CResult_COption_ClosureReasonZDecodeErrorZ_clone(this.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Result_COption_ClosureReasonZDecodeErrorZ ret_hu_conv = Result_COption_ClosureReasonZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+}
--- /dev/null
+package org.ldk.structs;
+
+import org.ldk.impl.bindings;
+import org.ldk.enums.*;
+import org.ldk.util.*;
+import java.util.Arrays;
+import javax.annotation.Nullable;
+
+public class Result_COption_EventZDecodeErrorZ extends CommonBase {
+ private Result_COption_EventZDecodeErrorZ(Object _dummy, long ptr) { super(ptr); }
+ protected void finalize() throws Throwable {
+ if (ptr != 0) { bindings.CResult_COption_EventZDecodeErrorZ_free(ptr); } super.finalize();
+ }
+
+ static Result_COption_EventZDecodeErrorZ constr_from_ptr(long ptr) {
+ if (bindings.CResult_COption_EventZDecodeErrorZ_is_ok(ptr)) {
+ return new Result_COption_EventZDecodeErrorZ_OK(null, ptr);
+ } else {
+ return new Result_COption_EventZDecodeErrorZ_Err(null, ptr);
+ }
+ }
+ public static final class Result_COption_EventZDecodeErrorZ_OK extends Result_COption_EventZDecodeErrorZ {
+ public final Option_EventZ res;
+ private Result_COption_EventZDecodeErrorZ_OK(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ long res = bindings.LDKCResult_COption_EventZDecodeErrorZ_get_ok(ptr);
+ Option_EventZ res_hu_conv = Option_EventZ.constr_from_ptr(res);
+ res_hu_conv.ptrs_to.add(this);
+ this.res = res_hu_conv;
+ }
+ }
+
+ public static final class Result_COption_EventZDecodeErrorZ_Err extends Result_COption_EventZDecodeErrorZ {
+ public final DecodeError err;
+ private Result_COption_EventZDecodeErrorZ_Err(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ long err = bindings.LDKCResult_COption_EventZDecodeErrorZ_get_err(ptr);
+ DecodeError err_hu_conv = null; if (err < 0 || err > 4096) { err_hu_conv = new DecodeError(null, err); }
+ err_hu_conv.ptrs_to.add(this);
+ this.err = err_hu_conv;
+ }
+ }
+
+ /**
+ * Creates a new CResult_COption_EventZDecodeErrorZ in the success state.
+ */
+ public static Result_COption_EventZDecodeErrorZ ok(Option_EventZ o) {
+ long ret = bindings.CResult_COption_EventZDecodeErrorZ_ok(o.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Result_COption_EventZDecodeErrorZ ret_hu_conv = Result_COption_EventZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ /**
+ * Creates a new CResult_COption_EventZDecodeErrorZ in the error state.
+ */
+ public static Result_COption_EventZDecodeErrorZ err(DecodeError e) {
+ long ret = bindings.CResult_COption_EventZDecodeErrorZ_err(e == null ? 0 : e.ptr & ~1);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Result_COption_EventZDecodeErrorZ ret_hu_conv = Result_COption_EventZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_COption_EventZDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_COption_EventZDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
+ /**
+ * Creates a new CResult_COption_EventZDecodeErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
+ */
+ public Result_COption_EventZDecodeErrorZ clone() {
+ long ret = bindings.CResult_COption_EventZDecodeErrorZ_clone(this.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Result_COption_EventZDecodeErrorZ ret_hu_conv = Result_COption_EventZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+}
--- /dev/null
+package org.ldk.structs;
+
+import org.ldk.impl.bindings;
+import org.ldk.enums.*;
+import org.ldk.util.*;
+import java.util.Arrays;
+import javax.annotation.Nullable;
+
+public class Result_COption_MonitorEventZDecodeErrorZ extends CommonBase {
+ private Result_COption_MonitorEventZDecodeErrorZ(Object _dummy, long ptr) { super(ptr); }
+ protected void finalize() throws Throwable {
+ if (ptr != 0) { bindings.CResult_COption_MonitorEventZDecodeErrorZ_free(ptr); } super.finalize();
+ }
+
+ static Result_COption_MonitorEventZDecodeErrorZ constr_from_ptr(long ptr) {
+ if (bindings.CResult_COption_MonitorEventZDecodeErrorZ_is_ok(ptr)) {
+ return new Result_COption_MonitorEventZDecodeErrorZ_OK(null, ptr);
+ } else {
+ return new Result_COption_MonitorEventZDecodeErrorZ_Err(null, ptr);
+ }
+ }
+ public static final class Result_COption_MonitorEventZDecodeErrorZ_OK extends Result_COption_MonitorEventZDecodeErrorZ {
+ public final Option_MonitorEventZ res;
+ private Result_COption_MonitorEventZDecodeErrorZ_OK(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ long res = bindings.LDKCResult_COption_MonitorEventZDecodeErrorZ_get_ok(ptr);
+ Option_MonitorEventZ res_hu_conv = Option_MonitorEventZ.constr_from_ptr(res);
+ res_hu_conv.ptrs_to.add(this);
+ this.res = res_hu_conv;
+ }
+ }
+
+ public static final class Result_COption_MonitorEventZDecodeErrorZ_Err extends Result_COption_MonitorEventZDecodeErrorZ {
+ public final DecodeError err;
+ private Result_COption_MonitorEventZDecodeErrorZ_Err(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ long err = bindings.LDKCResult_COption_MonitorEventZDecodeErrorZ_get_err(ptr);
+ DecodeError err_hu_conv = null; if (err < 0 || err > 4096) { err_hu_conv = new DecodeError(null, err); }
+ err_hu_conv.ptrs_to.add(this);
+ this.err = err_hu_conv;
+ }
+ }
+
+ /**
+ * Creates a new CResult_COption_MonitorEventZDecodeErrorZ in the success state.
+ */
+ public static Result_COption_MonitorEventZDecodeErrorZ ok(Option_MonitorEventZ o) {
+ long ret = bindings.CResult_COption_MonitorEventZDecodeErrorZ_ok(o.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Result_COption_MonitorEventZDecodeErrorZ ret_hu_conv = Result_COption_MonitorEventZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ /**
+ * Creates a new CResult_COption_MonitorEventZDecodeErrorZ in the error state.
+ */
+ public static Result_COption_MonitorEventZDecodeErrorZ err(DecodeError e) {
+ long ret = bindings.CResult_COption_MonitorEventZDecodeErrorZ_err(e == null ? 0 : e.ptr & ~1);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Result_COption_MonitorEventZDecodeErrorZ ret_hu_conv = Result_COption_MonitorEventZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_COption_MonitorEventZDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
+ /**
+ * Creates a new CResult_COption_MonitorEventZDecodeErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
+ */
+ public Result_COption_MonitorEventZDecodeErrorZ clone() {
+ long ret = bindings.CResult_COption_MonitorEventZDecodeErrorZ_clone(this.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Result_COption_MonitorEventZDecodeErrorZ ret_hu_conv = Result_COption_MonitorEventZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+}
--- /dev/null
+package org.ldk.structs;
+
+import org.ldk.impl.bindings;
+import org.ldk.enums.*;
+import org.ldk.util.*;
+import java.util.Arrays;
+import javax.annotation.Nullable;
+
+public class Result_COption_NetworkUpdateZDecodeErrorZ extends CommonBase {
+ private Result_COption_NetworkUpdateZDecodeErrorZ(Object _dummy, long ptr) { super(ptr); }
+ protected void finalize() throws Throwable {
+ if (ptr != 0) { bindings.CResult_COption_NetworkUpdateZDecodeErrorZ_free(ptr); } super.finalize();
+ }
+
+ static Result_COption_NetworkUpdateZDecodeErrorZ constr_from_ptr(long ptr) {
+ if (bindings.CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(ptr)) {
+ return new Result_COption_NetworkUpdateZDecodeErrorZ_OK(null, ptr);
+ } else {
+ return new Result_COption_NetworkUpdateZDecodeErrorZ_Err(null, ptr);
+ }
+ }
+ public static final class Result_COption_NetworkUpdateZDecodeErrorZ_OK extends Result_COption_NetworkUpdateZDecodeErrorZ {
+ public final Option_NetworkUpdateZ res;
+ private Result_COption_NetworkUpdateZDecodeErrorZ_OK(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ long res = bindings.LDKCResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(ptr);
+ Option_NetworkUpdateZ res_hu_conv = Option_NetworkUpdateZ.constr_from_ptr(res);
+ res_hu_conv.ptrs_to.add(this);
+ this.res = res_hu_conv;
+ }
+ }
+
+ public static final class Result_COption_NetworkUpdateZDecodeErrorZ_Err extends Result_COption_NetworkUpdateZDecodeErrorZ {
+ public final DecodeError err;
+ private Result_COption_NetworkUpdateZDecodeErrorZ_Err(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ long err = bindings.LDKCResult_COption_NetworkUpdateZDecodeErrorZ_get_err(ptr);
+ DecodeError err_hu_conv = null; if (err < 0 || err > 4096) { err_hu_conv = new DecodeError(null, err); }
+ err_hu_conv.ptrs_to.add(this);
+ this.err = err_hu_conv;
+ }
+ }
+
+ /**
+ * Creates a new CResult_COption_NetworkUpdateZDecodeErrorZ in the success state.
+ */
+ public static Result_COption_NetworkUpdateZDecodeErrorZ ok(Option_NetworkUpdateZ o) {
+ long ret = bindings.CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Result_COption_NetworkUpdateZDecodeErrorZ ret_hu_conv = Result_COption_NetworkUpdateZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ /**
+ * Creates a new CResult_COption_NetworkUpdateZDecodeErrorZ in the error state.
+ */
+ public static Result_COption_NetworkUpdateZDecodeErrorZ err(DecodeError e) {
+ long ret = bindings.CResult_COption_NetworkUpdateZDecodeErrorZ_err(e == null ? 0 : e.ptr & ~1);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Result_COption_NetworkUpdateZDecodeErrorZ ret_hu_conv = Result_COption_NetworkUpdateZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
+ /**
+ * Creates a new CResult_COption_NetworkUpdateZDecodeErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
+ */
+ public Result_COption_NetworkUpdateZDecodeErrorZ clone() {
+ long ret = bindings.CResult_COption_NetworkUpdateZDecodeErrorZ_clone(this.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Result_COption_NetworkUpdateZDecodeErrorZ ret_hu_conv = Result_COption_NetworkUpdateZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+}
}
static Result_COption_TypeZDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_COption_TypeZDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_COption_TypeZDecodeErrorZ_is_ok(ptr)) {
return new Result_COption_TypeZDecodeErrorZ_OK(null, ptr);
} else {
return new Result_COption_TypeZDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_COption_TypeZDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_COption_TypeZDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_COption_TypeZDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_is_ok(ptr)) {
return new Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_OK(null, ptr);
} else {
return new Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_CVec_CVec_u8ZZNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_CVec_CVec_u8ZZNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_CVec_CVec_u8ZZNoneZ_is_ok(ptr)) {
return new Result_CVec_CVec_u8ZZNoneZ_OK(null, ptr);
} else {
return new Result_CVec_CVec_u8ZZNoneZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_CVec_CVec_u8ZZNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_CVec_CVec_u8ZZNoneZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_CVec_SignatureZNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_CVec_SignatureZNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_CVec_SignatureZNoneZ_is_ok(ptr)) {
return new Result_CVec_SignatureZNoneZ_OK(null, ptr);
} else {
return new Result_CVec_SignatureZNoneZ_Err(null, ptr);
* Creates a new CResult_CVec_SignatureZNoneZ in the success state.
*/
public static Result_CVec_SignatureZNoneZ ok(byte[][] o) {
- long ret = bindings.CResult_CVec_SignatureZNoneZ_ok(o);
+ long ret = bindings.CResult_CVec_SignatureZNoneZ_ok(o != null ? Arrays.stream(o).map(o_conv_8 -> InternalUtils.check_arr_len(o_conv_8, 64)).toArray(byte[][]::new) : null);
if (ret >= 0 && ret <= 4096) { return null; }
Result_CVec_SignatureZNoneZ ret_hu_conv = Result_CVec_SignatureZNoneZ.constr_from_ptr(ret);
return ret_hu_conv;
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_CVec_SignatureZNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_CVec_SignatureZNoneZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_CVec_SignatureZNoneZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_CVec_u8ZPeerHandleErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_CVec_u8ZPeerHandleErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_CVec_u8ZPeerHandleErrorZ_is_ok(ptr)) {
return new Result_CVec_u8ZPeerHandleErrorZ_OK(null, ptr);
} else {
return new Result_CVec_u8ZPeerHandleErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_CVec_u8ZPeerHandleErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_CVec_u8ZPeerHandleErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_ChannelAnnouncementDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ChannelAnnouncementDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ChannelAnnouncementDecodeErrorZ_is_ok(ptr)) {
return new Result_ChannelAnnouncementDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ChannelAnnouncementDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ChannelAnnouncementDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_ChannelAnnouncementDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_ChannelConfigDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ChannelConfigDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ChannelConfigDecodeErrorZ_is_ok(ptr)) {
return new Result_ChannelConfigDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ChannelConfigDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ChannelConfigDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_ChannelConfigDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_ChannelConfigDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_ChannelFeaturesDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ChannelFeaturesDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ChannelFeaturesDecodeErrorZ_is_ok(ptr)) {
return new Result_ChannelFeaturesDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ChannelFeaturesDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ChannelFeaturesDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
}
}
static Result_ChannelInfoDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ChannelInfoDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ChannelInfoDecodeErrorZ_is_ok(ptr)) {
return new Result_ChannelInfoDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ChannelInfoDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ChannelInfoDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_ChannelInfoDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_ChannelInfoDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_ChannelMonitorUpdateDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ChannelMonitorUpdateDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(ptr)) {
return new Result_ChannelMonitorUpdateDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ChannelMonitorUpdateDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_ChannelMonitorUpdateDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_ChannelPublicKeysDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ChannelPublicKeysDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ChannelPublicKeysDecodeErrorZ_is_ok(ptr)) {
return new Result_ChannelPublicKeysDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ChannelPublicKeysDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ChannelPublicKeysDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_ChannelPublicKeysDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_ChannelReestablishDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ChannelReestablishDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ChannelReestablishDecodeErrorZ_is_ok(ptr)) {
return new Result_ChannelReestablishDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ChannelReestablishDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ChannelReestablishDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_ChannelReestablishDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_ChannelReestablishDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_ChannelTransactionParametersDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ChannelTransactionParametersDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(ptr)) {
return new Result_ChannelTransactionParametersDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ChannelTransactionParametersDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_ChannelTransactionParametersDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_ChannelUpdateDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ChannelUpdateDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ChannelUpdateDecodeErrorZ_is_ok(ptr)) {
return new Result_ChannelUpdateDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ChannelUpdateDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ChannelUpdateDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_ChannelUpdateDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_ChannelUpdateDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_ClosingSignedDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ClosingSignedDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ClosingSignedDecodeErrorZ_is_ok(ptr)) {
return new Result_ClosingSignedDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ClosingSignedDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ClosingSignedDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_ClosingSignedDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_ClosingSignedDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_ClosingSignedFeeRangeDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ClosingSignedFeeRangeDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(ptr)) {
return new Result_ClosingSignedFeeRangeDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ClosingSignedFeeRangeDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_ClosingSignedFeeRangeDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_CommitmentSignedDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_CommitmentSignedDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_CommitmentSignedDecodeErrorZ_is_ok(ptr)) {
return new Result_CommitmentSignedDecodeErrorZ_OK(null, ptr);
} else {
return new Result_CommitmentSignedDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_CommitmentSignedDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_CommitmentSignedDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_CommitmentSignedDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_CommitmentTransactionDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_CommitmentTransactionDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_CommitmentTransactionDecodeErrorZ_is_ok(ptr)) {
return new Result_CommitmentTransactionDecodeErrorZ_OK(null, ptr);
} else {
return new Result_CommitmentTransactionDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_CommitmentTransactionDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_CommitmentTransactionDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_CounterpartyChannelTransactionParametersDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(ptr)) {
return new Result_CounterpartyChannelTransactionParametersDecodeErrorZ_OK(null, ptr);
} else {
return new Result_CounterpartyChannelTransactionParametersDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_CounterpartyChannelTransactionParametersDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_DelayedPaymentOutputDescriptorDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(ptr)) {
return new Result_DelayedPaymentOutputDescriptorDecodeErrorZ_OK(null, ptr);
} else {
return new Result_DelayedPaymentOutputDescriptorDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_DelayedPaymentOutputDescriptorDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_DescriptionCreationErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_DescriptionCreationErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_DescriptionCreationErrorZ_is_ok(ptr)) {
return new Result_DescriptionCreationErrorZ_OK(null, ptr);
} else {
return new Result_DescriptionCreationErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_DescriptionCreationErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_DescriptionCreationErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_DescriptionCreationErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_DirectionalChannelInfoDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_DirectionalChannelInfoDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(ptr)) {
return new Result_DirectionalChannelInfoDecodeErrorZ_OK(null, ptr);
} else {
return new Result_DirectionalChannelInfoDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_DirectionalChannelInfoDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_ErrorMessageDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ErrorMessageDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ErrorMessageDecodeErrorZ_is_ok(ptr)) {
return new Result_ErrorMessageDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ErrorMessageDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ErrorMessageDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_ErrorMessageDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_ErrorMessageDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_ExpiryTimeCreationErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ExpiryTimeCreationErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ExpiryTimeCreationErrorZ_is_ok(ptr)) {
return new Result_ExpiryTimeCreationErrorZ_OK(null, ptr);
} else {
return new Result_ExpiryTimeCreationErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ExpiryTimeCreationErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_ExpiryTimeCreationErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_ExpiryTimeCreationErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_FundingCreatedDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_FundingCreatedDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_FundingCreatedDecodeErrorZ_is_ok(ptr)) {
return new Result_FundingCreatedDecodeErrorZ_OK(null, ptr);
} else {
return new Result_FundingCreatedDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_FundingCreatedDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_FundingCreatedDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_FundingCreatedDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_FundingLockedDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_FundingLockedDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_FundingLockedDecodeErrorZ_is_ok(ptr)) {
return new Result_FundingLockedDecodeErrorZ_OK(null, ptr);
} else {
return new Result_FundingLockedDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_FundingLockedDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_FundingLockedDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_FundingLockedDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_FundingSignedDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_FundingSignedDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_FundingSignedDecodeErrorZ_is_ok(ptr)) {
return new Result_FundingSignedDecodeErrorZ_OK(null, ptr);
} else {
return new Result_FundingSignedDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_FundingSignedDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_FundingSignedDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_FundingSignedDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_GossipTimestampFilterDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_GossipTimestampFilterDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_GossipTimestampFilterDecodeErrorZ_is_ok(ptr)) {
return new Result_GossipTimestampFilterDecodeErrorZ_OK(null, ptr);
} else {
return new Result_GossipTimestampFilterDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_GossipTimestampFilterDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_GossipTimestampFilterDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_HTLCOutputInCommitmentDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(ptr)) {
return new Result_HTLCOutputInCommitmentDecodeErrorZ_OK(null, ptr);
} else {
return new Result_HTLCOutputInCommitmentDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_HTLCOutputInCommitmentDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_HTLCUpdateDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_HTLCUpdateDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_HTLCUpdateDecodeErrorZ_is_ok(ptr)) {
return new Result_HTLCUpdateDecodeErrorZ_OK(null, ptr);
} else {
return new Result_HTLCUpdateDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_HTLCUpdateDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_HTLCUpdateDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_HTLCUpdateDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_HolderCommitmentTransactionDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_HolderCommitmentTransactionDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(ptr)) {
return new Result_HolderCommitmentTransactionDecodeErrorZ_OK(null, ptr);
} else {
return new Result_HolderCommitmentTransactionDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_HolderCommitmentTransactionDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_InMemorySignerDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_InMemorySignerDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_InMemorySignerDecodeErrorZ_is_ok(ptr)) {
return new Result_InMemorySignerDecodeErrorZ_OK(null, ptr);
} else {
return new Result_InMemorySignerDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_InMemorySignerDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_InMemorySignerDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_InMemorySignerDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_InitDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_InitDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_InitDecodeErrorZ_is_ok(ptr)) {
return new Result_InitDecodeErrorZ_OK(null, ptr);
} else {
return new Result_InitDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_InitDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_InitDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_InitDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_InitFeaturesDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_InitFeaturesDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_InitFeaturesDecodeErrorZ_is_ok(ptr)) {
return new Result_InitFeaturesDecodeErrorZ_OK(null, ptr);
} else {
return new Result_InitFeaturesDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_InitFeaturesDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
}
}
static Result_InvoiceFeaturesDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_InvoiceFeaturesDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_InvoiceFeaturesDecodeErrorZ_is_ok(ptr)) {
return new Result_InvoiceFeaturesDecodeErrorZ_OK(null, ptr);
} else {
return new Result_InvoiceFeaturesDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_InvoiceFeaturesDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
}
}
static Result_InvoiceNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_InvoiceNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_InvoiceNoneZ_is_ok(ptr)) {
return new Result_InvoiceNoneZ_OK(null, ptr);
} else {
return new Result_InvoiceNoneZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_InvoiceNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_InvoiceNoneZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_InvoiceNoneZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_InvoiceSemanticErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_InvoiceSemanticErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_InvoiceSemanticErrorZ_is_ok(ptr)) {
return new Result_InvoiceSemanticErrorZ_OK(null, ptr);
} else {
return new Result_InvoiceSemanticErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_InvoiceSemanticErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_InvoiceSemanticErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_InvoiceSemanticErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_InvoiceSignOrCreationErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_InvoiceSignOrCreationErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_InvoiceSignOrCreationErrorZ_is_ok(ptr)) {
return new Result_InvoiceSignOrCreationErrorZ_OK(null, ptr);
} else {
return new Result_InvoiceSignOrCreationErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_InvoiceSignOrCreationErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_InvoiceSignOrCreationErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_InvoiceSignOrCreationErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_LockedChannelMonitorNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_LockedChannelMonitorNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_LockedChannelMonitorNoneZ_is_ok(ptr)) {
return new Result_LockedChannelMonitorNoneZ_OK(null, ptr);
} else {
return new Result_LockedChannelMonitorNoneZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_LockedChannelMonitorNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
}
}
static Result_NetAddressDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NetAddressDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NetAddressDecodeErrorZ_is_ok(ptr)) {
return new Result_NetAddressDecodeErrorZ_OK(null, ptr);
} else {
return new Result_NetAddressDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NetAddressDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_NetAddressDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_NetAddressDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_NetworkGraphDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NetworkGraphDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NetworkGraphDecodeErrorZ_is_ok(ptr)) {
return new Result_NetworkGraphDecodeErrorZ_OK(null, ptr);
} else {
return new Result_NetworkGraphDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NetworkGraphDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_NetworkGraphDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_NetworkGraphDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_NodeAnnouncementDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NodeAnnouncementDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NodeAnnouncementDecodeErrorZ_is_ok(ptr)) {
return new Result_NodeAnnouncementDecodeErrorZ_OK(null, ptr);
} else {
return new Result_NodeAnnouncementDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NodeAnnouncementDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_NodeAnnouncementDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_NodeAnnouncementInfoDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NodeAnnouncementInfoDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(ptr)) {
return new Result_NodeAnnouncementInfoDecodeErrorZ_OK(null, ptr);
} else {
return new Result_NodeAnnouncementInfoDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_NodeAnnouncementInfoDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_NodeFeaturesDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NodeFeaturesDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NodeFeaturesDecodeErrorZ_is_ok(ptr)) {
return new Result_NodeFeaturesDecodeErrorZ_OK(null, ptr);
} else {
return new Result_NodeFeaturesDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NodeFeaturesDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
}
}
static Result_NodeIdDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NodeIdDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NodeIdDecodeErrorZ_is_ok(ptr)) {
return new Result_NodeIdDecodeErrorZ_OK(null, ptr);
} else {
return new Result_NodeIdDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NodeIdDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_NodeIdDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_NodeIdDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_NodeInfoDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NodeInfoDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NodeInfoDecodeErrorZ_is_ok(ptr)) {
return new Result_NodeInfoDecodeErrorZ_OK(null, ptr);
} else {
return new Result_NodeInfoDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NodeInfoDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_NodeInfoDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_NodeInfoDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_NoneAPIErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NoneAPIErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NoneAPIErrorZ_is_ok(ptr)) {
return new Result_NoneAPIErrorZ_OK(null, ptr);
} else {
return new Result_NoneAPIErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NoneAPIErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_NoneAPIErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_NoneAPIErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_NoneChannelMonitorUpdateErrZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NoneChannelMonitorUpdateErrZ_result_ok(ptr)) {
+ if (bindings.CResult_NoneChannelMonitorUpdateErrZ_is_ok(ptr)) {
return new Result_NoneChannelMonitorUpdateErrZ_OK(null, ptr);
} else {
return new Result_NoneChannelMonitorUpdateErrZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NoneChannelMonitorUpdateErrZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_NoneChannelMonitorUpdateErrZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_NoneErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NoneErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NoneErrorZ_is_ok(ptr)) {
return new Result_NoneErrorZ_OK(null, ptr);
} else {
return new Result_NoneErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NoneErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_NoneErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_NoneErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_NoneLightningErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NoneLightningErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NoneLightningErrorZ_is_ok(ptr)) {
return new Result_NoneLightningErrorZ_OK(null, ptr);
} else {
return new Result_NoneLightningErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NoneLightningErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_NoneLightningErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_NoneLightningErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_NoneMonitorUpdateErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NoneMonitorUpdateErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NoneMonitorUpdateErrorZ_is_ok(ptr)) {
return new Result_NoneMonitorUpdateErrorZ_OK(null, ptr);
} else {
return new Result_NoneMonitorUpdateErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NoneMonitorUpdateErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_NoneMonitorUpdateErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_NoneMonitorUpdateErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_NoneNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NoneNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_NoneNoneZ_is_ok(ptr)) {
return new Result_NoneNoneZ_OK(null, ptr);
} else {
return new Result_NoneNoneZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NoneNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_NoneNoneZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_NoneNoneZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_NonePaymentSendFailureZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NonePaymentSendFailureZ_result_ok(ptr)) {
+ if (bindings.CResult_NonePaymentSendFailureZ_is_ok(ptr)) {
return new Result_NonePaymentSendFailureZ_OK(null, ptr);
} else {
return new Result_NonePaymentSendFailureZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NonePaymentSendFailureZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_NonePaymentSendFailureZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_NonePaymentSendFailureZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_NonePeerHandleErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NonePeerHandleErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NonePeerHandleErrorZ_is_ok(ptr)) {
return new Result_NonePeerHandleErrorZ_OK(null, ptr);
} else {
return new Result_NonePeerHandleErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NonePeerHandleErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_NonePeerHandleErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_NonePeerHandleErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_NoneSemanticErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NoneSemanticErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NoneSemanticErrorZ_is_ok(ptr)) {
return new Result_NoneSemanticErrorZ_OK(null, ptr);
} else {
return new Result_NoneSemanticErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NoneSemanticErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_NoneSemanticErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_NoneSemanticErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_OpenChannelDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_OpenChannelDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_OpenChannelDecodeErrorZ_is_ok(ptr)) {
return new Result_OpenChannelDecodeErrorZ_OK(null, ptr);
} else {
return new Result_OpenChannelDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_OpenChannelDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_OpenChannelDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_OpenChannelDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_OutPointDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_OutPointDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_OutPointDecodeErrorZ_is_ok(ptr)) {
return new Result_OutPointDecodeErrorZ_OK(null, ptr);
} else {
return new Result_OutPointDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_OutPointDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_OutPointDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_OutPointDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_PayeeDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_PayeeDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_PayeeDecodeErrorZ_is_ok(ptr)) {
return new Result_PayeeDecodeErrorZ_OK(null, ptr);
} else {
return new Result_PayeeDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_PayeeDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_PayeeDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_PayeeDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_PayeePubKeyErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_PayeePubKeyErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_PayeePubKeyErrorZ_is_ok(ptr)) {
return new Result_PayeePubKeyErrorZ_OK(null, ptr);
} else {
return new Result_PayeePubKeyErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_PayeePubKeyErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_PayeePubKeyErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_PayeePubKeyErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_PaymentIdPaymentErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_PaymentIdPaymentErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_PaymentIdPaymentErrorZ_is_ok(ptr)) {
return new Result_PaymentIdPaymentErrorZ_OK(null, ptr);
} else {
return new Result_PaymentIdPaymentErrorZ_Err(null, ptr);
* Creates a new CResult_PaymentIdPaymentErrorZ in the success state.
*/
public static Result_PaymentIdPaymentErrorZ ok(byte[] o) {
- long ret = bindings.CResult_PaymentIdPaymentErrorZ_ok(o);
+ long ret = bindings.CResult_PaymentIdPaymentErrorZ_ok(InternalUtils.check_arr_len(o, 32));
if (ret >= 0 && ret <= 4096) { return null; }
Result_PaymentIdPaymentErrorZ ret_hu_conv = Result_PaymentIdPaymentErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_PaymentIdPaymentErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_PaymentIdPaymentErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_PaymentIdPaymentErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_PaymentIdPaymentSendFailureZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_PaymentIdPaymentSendFailureZ_result_ok(ptr)) {
+ if (bindings.CResult_PaymentIdPaymentSendFailureZ_is_ok(ptr)) {
return new Result_PaymentIdPaymentSendFailureZ_OK(null, ptr);
} else {
return new Result_PaymentIdPaymentSendFailureZ_Err(null, ptr);
* Creates a new CResult_PaymentIdPaymentSendFailureZ in the success state.
*/
public static Result_PaymentIdPaymentSendFailureZ ok(byte[] o) {
- long ret = bindings.CResult_PaymentIdPaymentSendFailureZ_ok(o);
+ long ret = bindings.CResult_PaymentIdPaymentSendFailureZ_ok(InternalUtils.check_arr_len(o, 32));
if (ret >= 0 && ret <= 4096) { return null; }
Result_PaymentIdPaymentSendFailureZ ret_hu_conv = Result_PaymentIdPaymentSendFailureZ.constr_from_ptr(ret);
return ret_hu_conv;
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_PaymentIdPaymentSendFailureZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_PaymentIdPaymentSendFailureZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_PaymentIdPaymentSendFailureZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_PaymentSecretAPIErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_PaymentSecretAPIErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_PaymentSecretAPIErrorZ_is_ok(ptr)) {
return new Result_PaymentSecretAPIErrorZ_OK(null, ptr);
} else {
return new Result_PaymentSecretAPIErrorZ_Err(null, ptr);
* Creates a new CResult_PaymentSecretAPIErrorZ in the success state.
*/
public static Result_PaymentSecretAPIErrorZ ok(byte[] o) {
- long ret = bindings.CResult_PaymentSecretAPIErrorZ_ok(o);
+ long ret = bindings.CResult_PaymentSecretAPIErrorZ_ok(InternalUtils.check_arr_len(o, 32));
if (ret >= 0 && ret <= 4096) { return null; }
Result_PaymentSecretAPIErrorZ ret_hu_conv = Result_PaymentSecretAPIErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_PaymentSecretAPIErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_PaymentSecretAPIErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_PaymentSecretAPIErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_PingDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_PingDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_PingDecodeErrorZ_is_ok(ptr)) {
return new Result_PingDecodeErrorZ_OK(null, ptr);
} else {
return new Result_PingDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_PingDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_PingDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_PingDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_PongDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_PongDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_PongDecodeErrorZ_is_ok(ptr)) {
return new Result_PongDecodeErrorZ_OK(null, ptr);
} else {
return new Result_PongDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_PongDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_PongDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_PongDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_PositiveTimestampCreationErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_PositiveTimestampCreationErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_PositiveTimestampCreationErrorZ_is_ok(ptr)) {
return new Result_PositiveTimestampCreationErrorZ_OK(null, ptr);
} else {
return new Result_PositiveTimestampCreationErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_PositiveTimestampCreationErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_PositiveTimestampCreationErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_PositiveTimestampCreationErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_PrivateRouteCreationErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_PrivateRouteCreationErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_PrivateRouteCreationErrorZ_is_ok(ptr)) {
return new Result_PrivateRouteCreationErrorZ_OK(null, ptr);
} else {
return new Result_PrivateRouteCreationErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_PrivateRouteCreationErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_PrivateRouteCreationErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_PrivateRouteCreationErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_PublicKeyErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_PublicKeyErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_PublicKeyErrorZ_is_ok(ptr)) {
return new Result_PublicKeyErrorZ_OK(null, ptr);
} else {
return new Result_PublicKeyErrorZ_Err(null, ptr);
* Creates a new CResult_PublicKeyErrorZ in the success state.
*/
public static Result_PublicKeyErrorZ ok(byte[] o) {
- long ret = bindings.CResult_PublicKeyErrorZ_ok(o);
+ long ret = bindings.CResult_PublicKeyErrorZ_ok(InternalUtils.check_arr_len(o, 33));
if (ret >= 0 && ret <= 4096) { return null; }
Result_PublicKeyErrorZ ret_hu_conv = Result_PublicKeyErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_PublicKeyErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_PublicKeyErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_PublicKeyErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_QueryChannelRangeDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_QueryChannelRangeDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_QueryChannelRangeDecodeErrorZ_is_ok(ptr)) {
return new Result_QueryChannelRangeDecodeErrorZ_OK(null, ptr);
} else {
return new Result_QueryChannelRangeDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_QueryChannelRangeDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_QueryChannelRangeDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_QueryShortChannelIdsDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_QueryShortChannelIdsDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(ptr)) {
return new Result_QueryShortChannelIdsDecodeErrorZ_OK(null, ptr);
} else {
return new Result_QueryShortChannelIdsDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_QueryShortChannelIdsDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_RecoverableSignatureNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_RecoverableSignatureNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_RecoverableSignatureNoneZ_is_ok(ptr)) {
return new Result_RecoverableSignatureNoneZ_OK(null, ptr);
} else {
return new Result_RecoverableSignatureNoneZ_Err(null, ptr);
* Creates a new CResult_RecoverableSignatureNoneZ in the success state.
*/
public static Result_RecoverableSignatureNoneZ ok(byte[] arg) {
- long ret = bindings.CResult_RecoverableSignatureNoneZ_ok(arg);
+ long ret = bindings.CResult_RecoverableSignatureNoneZ_ok(InternalUtils.check_arr_len(arg, 68));
if (ret >= 0 && ret <= 4096) { return null; }
Result_RecoverableSignatureNoneZ ret_hu_conv = Result_RecoverableSignatureNoneZ.constr_from_ptr(ret);
return ret_hu_conv;
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_RecoverableSignatureNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_RecoverableSignatureNoneZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_RecoverableSignatureNoneZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_ReplyChannelRangeDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ReplyChannelRangeDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ReplyChannelRangeDecodeErrorZ_is_ok(ptr)) {
return new Result_ReplyChannelRangeDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ReplyChannelRangeDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ReplyChannelRangeDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_ReplyChannelRangeDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_ReplyShortChannelIdsEndDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(ptr)) {
return new Result_ReplyShortChannelIdsEndDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ReplyShortChannelIdsEndDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_ReplyShortChannelIdsEndDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_RevokeAndACKDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_RevokeAndACKDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_RevokeAndACKDecodeErrorZ_is_ok(ptr)) {
return new Result_RevokeAndACKDecodeErrorZ_OK(null, ptr);
} else {
return new Result_RevokeAndACKDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_RevokeAndACKDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_RevokeAndACKDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_RevokeAndACKDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_RouteDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_RouteDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_RouteDecodeErrorZ_is_ok(ptr)) {
return new Result_RouteDecodeErrorZ_OK(null, ptr);
} else {
return new Result_RouteDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_RouteDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_RouteDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_RouteDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_RouteHintDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_RouteHintDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_RouteHintDecodeErrorZ_is_ok(ptr)) {
return new Result_RouteHintDecodeErrorZ_OK(null, ptr);
} else {
return new Result_RouteHintDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_RouteHintDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_RouteHintDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_RouteHintDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_RouteHintHopDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_RouteHintHopDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_RouteHintHopDecodeErrorZ_is_ok(ptr)) {
return new Result_RouteHintHopDecodeErrorZ_OK(null, ptr);
} else {
return new Result_RouteHintHopDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_RouteHintHopDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_RouteHintHopDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_RouteHintHopDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_RouteHopDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_RouteHopDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_RouteHopDecodeErrorZ_is_ok(ptr)) {
return new Result_RouteHopDecodeErrorZ_OK(null, ptr);
} else {
return new Result_RouteHopDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_RouteHopDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_RouteHopDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_RouteHopDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_RouteLightningErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_RouteLightningErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_RouteLightningErrorZ_is_ok(ptr)) {
return new Result_RouteLightningErrorZ_OK(null, ptr);
} else {
return new Result_RouteLightningErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_RouteLightningErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_RouteLightningErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_RouteLightningErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_RouteParametersDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_RouteParametersDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_RouteParametersDecodeErrorZ_is_ok(ptr)) {
return new Result_RouteParametersDecodeErrorZ_OK(null, ptr);
} else {
return new Result_RouteParametersDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_RouteParametersDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_RouteParametersDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_RouteParametersDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_RoutingFeesDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_RoutingFeesDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_RoutingFeesDecodeErrorZ_is_ok(ptr)) {
return new Result_RoutingFeesDecodeErrorZ_OK(null, ptr);
} else {
return new Result_RoutingFeesDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_RoutingFeesDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_RoutingFeesDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_RoutingFeesDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
--- /dev/null
+package org.ldk.structs;
+
+import org.ldk.impl.bindings;
+import org.ldk.enums.*;
+import org.ldk.util.*;
+import java.util.Arrays;
+import javax.annotation.Nullable;
+
+public class Result_ScorerDecodeErrorZ extends CommonBase {
+ private Result_ScorerDecodeErrorZ(Object _dummy, long ptr) { super(ptr); }
+ protected void finalize() throws Throwable {
+ if (ptr != 0) { bindings.CResult_ScorerDecodeErrorZ_free(ptr); } super.finalize();
+ }
+
+ static Result_ScorerDecodeErrorZ constr_from_ptr(long ptr) {
+ if (bindings.CResult_ScorerDecodeErrorZ_is_ok(ptr)) {
+ return new Result_ScorerDecodeErrorZ_OK(null, ptr);
+ } else {
+ return new Result_ScorerDecodeErrorZ_Err(null, ptr);
+ }
+ }
+ public static final class Result_ScorerDecodeErrorZ_OK extends Result_ScorerDecodeErrorZ {
+ public final Scorer res;
+ private Result_ScorerDecodeErrorZ_OK(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ long res = bindings.LDKCResult_ScorerDecodeErrorZ_get_ok(ptr);
+ Scorer res_hu_conv = null; if (res < 0 || res > 4096) { res_hu_conv = new Scorer(null, res); }
+ res_hu_conv.ptrs_to.add(this);
+ this.res = res_hu_conv;
+ }
+ }
+
+ public static final class Result_ScorerDecodeErrorZ_Err extends Result_ScorerDecodeErrorZ {
+ public final DecodeError err;
+ private Result_ScorerDecodeErrorZ_Err(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ long err = bindings.LDKCResult_ScorerDecodeErrorZ_get_err(ptr);
+ DecodeError err_hu_conv = null; if (err < 0 || err > 4096) { err_hu_conv = new DecodeError(null, err); }
+ err_hu_conv.ptrs_to.add(this);
+ this.err = err_hu_conv;
+ }
+ }
+
+ /**
+ * Creates a new CResult_ScorerDecodeErrorZ in the success state.
+ */
+ public static Result_ScorerDecodeErrorZ ok(ScoringParameters o_params) {
+ long ret = bindings.CResult_ScorerDecodeErrorZ_ok(bindings.Scorer_new(o_params == null ? 0 : o_params.ptr & ~1));
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Result_ScorerDecodeErrorZ ret_hu_conv = Result_ScorerDecodeErrorZ.constr_from_ptr(ret);
+ ret_hu_conv.ptrs_to.add(o_params);
+// Due to rust's strict-ownership memory model, in some cases we need to "move"
+// an object to pass exclusive ownership to the function being called.
+// In most cases, we avoid ret_hu_conv being visible in GC'd languages by cloning the object
+// at the FFI layer, creating a new object which Rust can claim ownership of
+// However, in some cases (eg here), there is no way to clone an object, and thus
+// we actually have to pass full ownership to Rust.
+// Thus, after ret_hu_conv call, o_params is reset to null and is now a dummy object.
+o_params.ptr = 0;
+ return ret_hu_conv;
+ }
+
+ /**
+ * Creates a new CResult_ScorerDecodeErrorZ in the error state.
+ */
+ public static Result_ScorerDecodeErrorZ err(DecodeError e) {
+ long ret = bindings.CResult_ScorerDecodeErrorZ_err(e == null ? 0 : e.ptr & ~1);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Result_ScorerDecodeErrorZ ret_hu_conv = Result_ScorerDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ScorerDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+}
--- /dev/null
+package org.ldk.structs;
+
+import org.ldk.impl.bindings;
+import org.ldk.enums.*;
+import org.ldk.util.*;
+import java.util.Arrays;
+import javax.annotation.Nullable;
+
+public class Result_ScoringParametersDecodeErrorZ extends CommonBase {
+ private Result_ScoringParametersDecodeErrorZ(Object _dummy, long ptr) { super(ptr); }
+ protected void finalize() throws Throwable {
+ if (ptr != 0) { bindings.CResult_ScoringParametersDecodeErrorZ_free(ptr); } super.finalize();
+ }
+
+ static Result_ScoringParametersDecodeErrorZ constr_from_ptr(long ptr) {
+ if (bindings.CResult_ScoringParametersDecodeErrorZ_is_ok(ptr)) {
+ return new Result_ScoringParametersDecodeErrorZ_OK(null, ptr);
+ } else {
+ return new Result_ScoringParametersDecodeErrorZ_Err(null, ptr);
+ }
+ }
+ public static final class Result_ScoringParametersDecodeErrorZ_OK extends Result_ScoringParametersDecodeErrorZ {
+ public final ScoringParameters res;
+ private Result_ScoringParametersDecodeErrorZ_OK(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ long res = bindings.LDKCResult_ScoringParametersDecodeErrorZ_get_ok(ptr);
+ ScoringParameters res_hu_conv = null; if (res < 0 || res > 4096) { res_hu_conv = new ScoringParameters(null, res); }
+ res_hu_conv.ptrs_to.add(this);
+ this.res = res_hu_conv;
+ }
+ }
+
+ public static final class Result_ScoringParametersDecodeErrorZ_Err extends Result_ScoringParametersDecodeErrorZ {
+ public final DecodeError err;
+ private Result_ScoringParametersDecodeErrorZ_Err(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ long err = bindings.LDKCResult_ScoringParametersDecodeErrorZ_get_err(ptr);
+ DecodeError err_hu_conv = null; if (err < 0 || err > 4096) { err_hu_conv = new DecodeError(null, err); }
+ err_hu_conv.ptrs_to.add(this);
+ this.err = err_hu_conv;
+ }
+ }
+
+ /**
+ * Creates a new CResult_ScoringParametersDecodeErrorZ in the success state.
+ */
+ public static Result_ScoringParametersDecodeErrorZ ok(long o_base_penalty_msat_arg, long o_failure_penalty_msat_arg, long o_failure_penalty_half_life_arg) {
+ long ret = bindings.CResult_ScoringParametersDecodeErrorZ_ok(bindings.ScoringParameters_new(o_base_penalty_msat_arg, o_failure_penalty_msat_arg, o_failure_penalty_half_life_arg));
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Result_ScoringParametersDecodeErrorZ ret_hu_conv = Result_ScoringParametersDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ /**
+ * Creates a new CResult_ScoringParametersDecodeErrorZ in the error state.
+ */
+ public static Result_ScoringParametersDecodeErrorZ err(DecodeError e) {
+ long ret = bindings.CResult_ScoringParametersDecodeErrorZ_err(e == null ? 0 : e.ptr & ~1);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Result_ScoringParametersDecodeErrorZ ret_hu_conv = Result_ScoringParametersDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ScoringParametersDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+}
}
static Result_SecretKeyErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_SecretKeyErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_SecretKeyErrorZ_is_ok(ptr)) {
return new Result_SecretKeyErrorZ_OK(null, ptr);
} else {
return new Result_SecretKeyErrorZ_Err(null, ptr);
* Creates a new CResult_SecretKeyErrorZ in the success state.
*/
public static Result_SecretKeyErrorZ ok(byte[] o) {
- long ret = bindings.CResult_SecretKeyErrorZ_ok(o);
+ long ret = bindings.CResult_SecretKeyErrorZ_ok(InternalUtils.check_arr_len(o, 32));
if (ret >= 0 && ret <= 4096) { return null; }
Result_SecretKeyErrorZ ret_hu_conv = Result_SecretKeyErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_SecretKeyErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
}
}
static Result_ShutdownDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ShutdownDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ShutdownDecodeErrorZ_is_ok(ptr)) {
return new Result_ShutdownDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ShutdownDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ShutdownDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_ShutdownDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_ShutdownDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_ShutdownScriptDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ShutdownScriptDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ShutdownScriptDecodeErrorZ_is_ok(ptr)) {
return new Result_ShutdownScriptDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ShutdownScriptDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ShutdownScriptDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_ShutdownScriptDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_ShutdownScriptDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_ShutdownScriptInvalidShutdownScriptZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ShutdownScriptInvalidShutdownScriptZ_result_ok(ptr)) {
+ if (bindings.CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(ptr)) {
return new Result_ShutdownScriptInvalidShutdownScriptZ_OK(null, ptr);
} else {
return new Result_ShutdownScriptInvalidShutdownScriptZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_ShutdownScriptInvalidShutdownScriptZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_SiPrefixNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_SiPrefixNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_SiPrefixNoneZ_is_ok(ptr)) {
return new Result_SiPrefixNoneZ_OK(null, ptr);
} else {
return new Result_SiPrefixNoneZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_SiPrefixNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_SiPrefixNoneZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_SiPrefixNoneZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_SignDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_SignDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_SignDecodeErrorZ_is_ok(ptr)) {
return new Result_SignDecodeErrorZ_OK(null, ptr);
} else {
return new Result_SignDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_SignDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_SignDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_SignDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_SignatureNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_SignatureNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_SignatureNoneZ_is_ok(ptr)) {
return new Result_SignatureNoneZ_OK(null, ptr);
} else {
return new Result_SignatureNoneZ_Err(null, ptr);
* Creates a new CResult_SignatureNoneZ in the success state.
*/
public static Result_SignatureNoneZ ok(byte[] o) {
- long ret = bindings.CResult_SignatureNoneZ_ok(o);
+ long ret = bindings.CResult_SignatureNoneZ_ok(InternalUtils.check_arr_len(o, 64));
if (ret >= 0 && ret <= 4096) { return null; }
Result_SignatureNoneZ ret_hu_conv = Result_SignatureNoneZ.constr_from_ptr(ret);
return ret_hu_conv;
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_SignatureNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_SignatureNoneZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_SignatureNoneZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_SignedRawInvoiceNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_SignedRawInvoiceNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_SignedRawInvoiceNoneZ_is_ok(ptr)) {
return new Result_SignedRawInvoiceNoneZ_OK(null, ptr);
} else {
return new Result_SignedRawInvoiceNoneZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_SignedRawInvoiceNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_SignedRawInvoiceNoneZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_SignedRawInvoiceNoneZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_SpendableOutputDescriptorDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_SpendableOutputDescriptorDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(ptr)) {
return new Result_SpendableOutputDescriptorDecodeErrorZ_OK(null, ptr);
} else {
return new Result_SpendableOutputDescriptorDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_SpendableOutputDescriptorDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_StaticPaymentOutputDescriptorDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(ptr)) {
return new Result_StaticPaymentOutputDescriptorDecodeErrorZ_OK(null, ptr);
} else {
return new Result_StaticPaymentOutputDescriptorDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_StaticPaymentOutputDescriptorDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_StringErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_StringErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_StringErrorZ_is_ok(ptr)) {
return new Result_StringErrorZ_OK(null, ptr);
} else {
return new Result_StringErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_StringErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
}
}
static Result_TransactionNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_TransactionNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_TransactionNoneZ_is_ok(ptr)) {
return new Result_TransactionNoneZ_OK(null, ptr);
} else {
return new Result_TransactionNoneZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_TransactionNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_TransactionNoneZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_TransactionNoneZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_TrustedClosingTransactionNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_TrustedClosingTransactionNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_TrustedClosingTransactionNoneZ_is_ok(ptr)) {
return new Result_TrustedClosingTransactionNoneZ_OK(null, ptr);
} else {
return new Result_TrustedClosingTransactionNoneZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_TrustedClosingTransactionNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
}
}
static Result_TrustedCommitmentTransactionNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_TrustedCommitmentTransactionNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_TrustedCommitmentTransactionNoneZ_is_ok(ptr)) {
return new Result_TrustedCommitmentTransactionNoneZ_OK(null, ptr);
} else {
return new Result_TrustedCommitmentTransactionNoneZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_TrustedCommitmentTransactionNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
}
}
static Result_TxCreationKeysDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_TxCreationKeysDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_TxCreationKeysDecodeErrorZ_is_ok(ptr)) {
return new Result_TxCreationKeysDecodeErrorZ_OK(null, ptr);
} else {
return new Result_TxCreationKeysDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_TxCreationKeysDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_TxCreationKeysDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_TxCreationKeysDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_TxCreationKeysErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_TxCreationKeysErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_TxCreationKeysErrorZ_is_ok(ptr)) {
return new Result_TxCreationKeysErrorZ_OK(null, ptr);
} else {
return new Result_TxCreationKeysErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_TxCreationKeysErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_TxCreationKeysErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_TxCreationKeysErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_TxOutAccessErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_TxOutAccessErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_TxOutAccessErrorZ_is_ok(ptr)) {
return new Result_TxOutAccessErrorZ_OK(null, ptr);
} else {
return new Result_TxOutAccessErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_TxOutAccessErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_TxOutAccessErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_TxOutAccessErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_UnsignedChannelAnnouncementDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(ptr)) {
return new Result_UnsignedChannelAnnouncementDecodeErrorZ_OK(null, ptr);
} else {
return new Result_UnsignedChannelAnnouncementDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_UnsignedChannelAnnouncementDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_UnsignedChannelUpdateDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_UnsignedChannelUpdateDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(ptr)) {
return new Result_UnsignedChannelUpdateDecodeErrorZ_OK(null, ptr);
} else {
return new Result_UnsignedChannelUpdateDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_UnsignedChannelUpdateDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_UnsignedNodeAnnouncementDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(ptr)) {
return new Result_UnsignedNodeAnnouncementDecodeErrorZ_OK(null, ptr);
} else {
return new Result_UnsignedNodeAnnouncementDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_UnsignedNodeAnnouncementDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_UpdateAddHTLCDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_UpdateAddHTLCDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_UpdateAddHTLCDecodeErrorZ_is_ok(ptr)) {
return new Result_UpdateAddHTLCDecodeErrorZ_OK(null, ptr);
} else {
return new Result_UpdateAddHTLCDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_UpdateAddHTLCDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_UpdateAddHTLCDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_UpdateFailHTLCDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_UpdateFailHTLCDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_UpdateFailHTLCDecodeErrorZ_is_ok(ptr)) {
return new Result_UpdateFailHTLCDecodeErrorZ_OK(null, ptr);
} else {
return new Result_UpdateFailHTLCDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_UpdateFailHTLCDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_UpdateFailHTLCDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_UpdateFailMalformedHTLCDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(ptr)) {
return new Result_UpdateFailMalformedHTLCDecodeErrorZ_OK(null, ptr);
} else {
return new Result_UpdateFailMalformedHTLCDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_UpdateFailMalformedHTLCDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_UpdateFeeDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_UpdateFeeDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_UpdateFeeDecodeErrorZ_is_ok(ptr)) {
return new Result_UpdateFeeDecodeErrorZ_OK(null, ptr);
} else {
return new Result_UpdateFeeDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_UpdateFeeDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_UpdateFeeDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_UpdateFeeDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_UpdateFulfillHTLCDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_UpdateFulfillHTLCDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(ptr)) {
return new Result_UpdateFulfillHTLCDecodeErrorZ_OK(null, ptr);
} else {
return new Result_UpdateFulfillHTLCDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_UpdateFulfillHTLCDecodeErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result__u832APIErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult__u832APIErrorZ_result_ok(ptr)) {
+ if (bindings.CResult__u832APIErrorZ_is_ok(ptr)) {
return new Result__u832APIErrorZ_OK(null, ptr);
} else {
return new Result__u832APIErrorZ_Err(null, ptr);
* Creates a new CResult__u832APIErrorZ in the success state.
*/
public static Result__u832APIErrorZ ok(byte[] o) {
- long ret = bindings.CResult__u832APIErrorZ_ok(o);
+ long ret = bindings.CResult__u832APIErrorZ_ok(InternalUtils.check_arr_len(o, 32));
if (ret >= 0 && ret <= 4096) { return null; }
Result__u832APIErrorZ ret_hu_conv = Result__u832APIErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult__u832APIErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult__u832APIErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult__u832APIErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_boolLightningErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_boolLightningErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_boolLightningErrorZ_is_ok(ptr)) {
return new Result_boolLightningErrorZ_OK(null, ptr);
} else {
return new Result_boolLightningErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_boolLightningErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_boolLightningErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_boolLightningErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
}
static Result_boolPeerHandleErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_boolPeerHandleErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_boolPeerHandleErrorZ_is_ok(ptr)) {
return new Result_boolPeerHandleErrorZ_OK(null, ptr);
} else {
return new Result_boolPeerHandleErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ /**
+ * Checks if the given object is currently in the success state
+ */
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_boolPeerHandleErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.CResult_boolPeerHandleErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new CResult_boolPeerHandleErrorZ which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.RetryAttempts_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the RetryAttempts
*/
* The channel ID
*/
public void set_channel_id(byte[] val) {
- bindings.RevokeAndACK_set_channel_id(this.ptr, val);
+ bindings.RevokeAndACK_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* The secret corresponding to the per-commitment point
*/
public void set_per_commitment_secret(byte[] val) {
- bindings.RevokeAndACK_set_per_commitment_secret(this.ptr, val);
+ bindings.RevokeAndACK_set_per_commitment_secret(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* The next sender-broadcast commitment transaction's per-commitment point
*/
public void set_next_per_commitment_point(byte[] val) {
- bindings.RevokeAndACK_set_next_per_commitment_point(this.ptr, val);
+ bindings.RevokeAndACK_set_next_per_commitment_point(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* Constructs a new RevokeAndACK given each field
*/
public static RevokeAndACK of(byte[] channel_id_arg, byte[] per_commitment_secret_arg, byte[] next_per_commitment_point_arg) {
- long ret = bindings.RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
+ long ret = bindings.RevokeAndACK_new(InternalUtils.check_arr_len(channel_id_arg, 32), InternalUtils.check_arr_len(per_commitment_secret_arg, 32), InternalUtils.check_arr_len(next_per_commitment_point_arg, 33));
if (ret >= 0 && ret <= 4096) { return null; }
RevokeAndACK ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new RevokeAndACK(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.RevokeAndACK_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the RevokeAndACK
*/
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.Route_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the Route
*/
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.RouteHint_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the RouteHint
*/
* The node_id of the non-target end of the route
*/
public void set_src_node_id(byte[] val) {
- bindings.RouteHintHop_set_src_node_id(this.ptr, val);
+ bindings.RouteHintHop_set_src_node_id(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* Constructs a new RouteHintHop given each field
*/
public static RouteHintHop of(byte[] src_node_id_arg, long short_channel_id_arg, RoutingFees fees_arg, short cltv_expiry_delta_arg, Option_u64Z htlc_minimum_msat_arg, Option_u64Z htlc_maximum_msat_arg) {
- long ret = bindings.RouteHintHop_new(src_node_id_arg, short_channel_id_arg, fees_arg == null ? 0 : fees_arg.ptr & ~1, cltv_expiry_delta_arg, htlc_minimum_msat_arg.ptr, htlc_maximum_msat_arg.ptr);
+ long ret = bindings.RouteHintHop_new(InternalUtils.check_arr_len(src_node_id_arg, 33), short_channel_id_arg, fees_arg == null ? 0 : fees_arg.ptr & ~1, cltv_expiry_delta_arg, htlc_minimum_msat_arg.ptr, htlc_maximum_msat_arg.ptr);
if (ret >= 0 && ret <= 4096) { return null; }
RouteHintHop ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new RouteHintHop(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.RouteHintHop_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the RouteHintHop
*/
* The node_id of the node at this hop.
*/
public void set_pubkey(byte[] val) {
- bindings.RouteHop_set_pubkey(this.ptr, val);
+ bindings.RouteHop_set_pubkey(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* Constructs a new RouteHop given each field
*/
public static RouteHop of(byte[] pubkey_arg, NodeFeatures node_features_arg, long short_channel_id_arg, ChannelFeatures channel_features_arg, long fee_msat_arg, int cltv_expiry_delta_arg) {
- long ret = bindings.RouteHop_new(pubkey_arg, node_features_arg == null ? 0 : node_features_arg.ptr & ~1, short_channel_id_arg, channel_features_arg == null ? 0 : channel_features_arg.ptr & ~1, fee_msat_arg, cltv_expiry_delta_arg);
+ long ret = bindings.RouteHop_new(InternalUtils.check_arr_len(pubkey_arg, 33), node_features_arg == null ? 0 : node_features_arg.ptr & ~1, short_channel_id_arg, channel_features_arg == null ? 0 : channel_features_arg.ptr & ~1, fee_msat_arg, cltv_expiry_delta_arg);
if (ret >= 0 && ret <= 4096) { return null; }
RouteHop ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new RouteHop(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.RouteHop_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the RouteHop
*/
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.RouteParameters_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the RouteParameters
*/
Score ret_hu_conv = new Score(null, scorer);
ret_hu_conv.ptrs_to.add(this);
Result_RouteLightningErrorZ ret = arg.find_route(payer, params_hu_conv, first_hops_conv_16_arr, ret_hu_conv);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
});
* Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
*/
public Result_RouteLightningErrorZ find_route(byte[] payer, RouteParameters params, @Nullable ChannelDetails[] first_hops, Score scorer) {
- long ret = bindings.Router_find_route(this.ptr, payer, params == null ? 0 : params.ptr & ~1, first_hops != null ? Arrays.stream(first_hops).mapToLong(first_hops_conv_16 -> first_hops_conv_16 == null ? 0 : first_hops_conv_16.ptr & ~1).toArray() : null, scorer == null ? 0 : scorer.ptr);
+ long ret = bindings.Router_find_route(this.ptr, InternalUtils.check_arr_len(payer, 33), params == null ? 0 : params.ptr & ~1, first_hops != null ? Arrays.stream(first_hops).mapToLong(first_hops_conv_16 -> first_hops_conv_16 == null ? 0 : first_hops_conv_16.ptr & ~1).toArray() : null, scorer == null ? 0 : scorer.ptr);
if (ret >= 0 && ret <= 4096) { return null; }
Result_RouteLightningErrorZ ret_hu_conv = Result_RouteLightningErrorZ.constr_from_ptr(ret);
this.ptrs_to.add(params);
return ret;
}
+ long clone_ptr() {
+ long ret = bindings.RoutingFees_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the RoutingFees
*/
@Override public long handle_node_announcement(long msg) {
NodeAnnouncement msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new NodeAnnouncement(null, msg); }
Result_boolLightningErrorZ ret = arg.handle_node_announcement(msg_hu_conv);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
@Override public long handle_channel_announcement(long msg) {
ChannelAnnouncement msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new ChannelAnnouncement(null, msg); }
Result_boolLightningErrorZ ret = arg.handle_channel_announcement(msg_hu_conv);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
@Override public long handle_channel_update(long msg) {
ChannelUpdate msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new ChannelUpdate(null, msg); }
Result_boolLightningErrorZ ret = arg.handle_channel_update(msg_hu_conv);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
@Override public long[] get_next_channel_announcements(long starting_point, byte batch_amount) {
ThreeTuple_ChannelAnnouncementChannelUpdateChannelUpdateZ[] ret = arg.get_next_channel_announcements(starting_point, batch_amount);
- long[] result = ret != null ? Arrays.stream(ret).mapToLong(ret_conv_59 -> ret_conv_59 != null ? ret_conv_59.ptr : 0).toArray() : null;
+ long[] result = ret != null ? Arrays.stream(ret).mapToLong(ret_conv_59 -> ret_conv_59 == null ? 0 : ret_conv_59.clone_ptr()).toArray() : null;
return result;
}
@Override public long[] get_next_node_announcements(byte[] starting_point, byte batch_amount) {
NodeAnnouncement[] ret = arg.get_next_node_announcements(starting_point, batch_amount);
- long[] result = ret != null ? Arrays.stream(ret).mapToLong(ret_conv_18 -> ret_conv_18 == null ? 0 : ret_conv_18.ptr & ~1).toArray() : null;
+ long[] result = ret != null ? Arrays.stream(ret).mapToLong(ret_conv_18 -> ret_conv_18 == null ? 0 : ret_conv_18.clone_ptr()).toArray() : null;
return result;
}
@Override public void sync_routing_table(byte[] their_node_id, long init) {
ReplyChannelRange msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new ReplyChannelRange(null, msg); }
msg_hu_conv.ptrs_to.add(this);
Result_NoneLightningErrorZ ret = arg.handle_reply_channel_range(their_node_id, msg_hu_conv);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
@Override public long handle_reply_short_channel_ids_end(byte[] their_node_id, long msg) {
ReplyShortChannelIdsEnd msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new ReplyShortChannelIdsEnd(null, msg); }
msg_hu_conv.ptrs_to.add(this);
Result_NoneLightningErrorZ ret = arg.handle_reply_short_channel_ids_end(their_node_id, msg_hu_conv);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
@Override public long handle_query_channel_range(byte[] their_node_id, long msg) {
QueryChannelRange msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new QueryChannelRange(null, msg); }
msg_hu_conv.ptrs_to.add(this);
Result_NoneLightningErrorZ ret = arg.handle_query_channel_range(their_node_id, msg_hu_conv);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
@Override public long handle_query_short_channel_ids(byte[] their_node_id, long msg) {
QueryShortChannelIds msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new QueryShortChannelIds(null, msg); }
msg_hu_conv.ptrs_to.add(this);
Result_NoneLightningErrorZ ret = arg.handle_query_short_channel_ids(their_node_id, msg_hu_conv);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
}, MessageSendEventsProvider.new_impl(MessageSendEventsProvider_impl).bindings_instance);
* Note that starting_point (or a relevant inner pointer) may be NULL or all-0s to represent None
*/
public NodeAnnouncement[] get_next_node_announcements(@Nullable byte[] starting_point, byte batch_amount) {
- long[] ret = bindings.RoutingMessageHandler_get_next_node_announcements(this.ptr, starting_point, batch_amount);
+ long[] ret = bindings.RoutingMessageHandler_get_next_node_announcements(this.ptr, InternalUtils.check_arr_len(starting_point, 33), batch_amount);
NodeAnnouncement[] ret_conv_18_arr = new NodeAnnouncement[ret.length];
for (int s = 0; s < ret.length; s++) {
long ret_conv_18 = ret[s];
* implementor.
*/
public void sync_routing_table(byte[] their_node_id, Init init) {
- bindings.RoutingMessageHandler_sync_routing_table(this.ptr, their_node_id, init == null ? 0 : init.ptr & ~1);
+ bindings.RoutingMessageHandler_sync_routing_table(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), init == null ? 0 : init.ptr & ~1);
this.ptrs_to.add(init);
}
* replies to a single query.
*/
public Result_NoneLightningErrorZ handle_reply_channel_range(byte[] their_node_id, ReplyChannelRange msg) {
- long ret = bindings.RoutingMessageHandler_handle_reply_channel_range(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ long ret = bindings.RoutingMessageHandler_handle_reply_channel_range(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
* gossip messages.
*/
public Result_NoneLightningErrorZ handle_reply_short_channel_ids_end(byte[] their_node_id, ReplyShortChannelIdsEnd msg) {
- long ret = bindings.RoutingMessageHandler_handle_reply_short_channel_ids_end(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ long ret = bindings.RoutingMessageHandler_handle_reply_short_channel_ids_end(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
* for the requested range of blocks.
*/
public Result_NoneLightningErrorZ handle_query_channel_range(byte[] their_node_id, QueryChannelRange msg) {
- long ret = bindings.RoutingMessageHandler_handle_query_channel_range(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ long ret = bindings.RoutingMessageHandler_handle_query_channel_range(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
* list of short_channel_ids.
*/
public Result_NoneLightningErrorZ handle_query_short_channel_ids(byte[] their_node_id, QueryShortChannelIds msg) {
- long ret = bindings.RoutingMessageHandler_handle_query_short_channel_ids(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ long ret = bindings.RoutingMessageHandler_handle_query_short_channel_ids(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
if (ptr != 0) { bindings.Sha256_free(ptr); }
}
+ long clone_ptr() {
+ long ret = bindings.Sha256_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the Sha256
*/
* The channel ID
*/
public void set_channel_id(byte[] val) {
- bindings.Shutdown_set_channel_id(this.ptr, val);
+ bindings.Shutdown_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* Constructs a new Shutdown given each field
*/
public static Shutdown of(byte[] channel_id_arg, byte[] scriptpubkey_arg) {
- long ret = bindings.Shutdown_new(channel_id_arg, scriptpubkey_arg);
+ long ret = bindings.Shutdown_new(InternalUtils.check_arr_len(channel_id_arg, 32), scriptpubkey_arg);
if (ret >= 0 && ret <= 4096) { return null; }
Shutdown ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new Shutdown(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.Shutdown_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the Shutdown
*/
if (ptr != 0) { bindings.ShutdownScript_free(ptr); }
}
+ long clone_ptr() {
+ long ret = bindings.ShutdownScript_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the ShutdownScript
*/
* Generates a P2WPKH script pubkey from the given [`WPubkeyHash`].
*/
public static ShutdownScript new_p2wpkh(byte[] pubkey_hash) {
- long ret = bindings.ShutdownScript_new_p2wpkh(pubkey_hash);
+ long ret = bindings.ShutdownScript_new_p2wpkh(InternalUtils.check_arr_len(pubkey_hash, 20));
if (ret >= 0 && ret <= 4096) { return null; }
ShutdownScript ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new ShutdownScript(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
* Generates a P2WSH script pubkey from the given [`WScriptHash`].
*/
public static ShutdownScript new_p2wsh(byte[] script_hash) {
- long ret = bindings.ShutdownScript_new_p2wsh(script_hash);
+ long ret = bindings.ShutdownScript_new_p2wsh(InternalUtils.check_arr_len(script_hash, 32));
if (ret >= 0 && ret <= 4096) { return null; }
ShutdownScript ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new ShutdownScript(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
final bindings.LDKSign bindings_instance;
Sign(Object _dummy, long ptr) { super(ptr); bindings_instance = null; }
private Sign(bindings.LDKSign arg, bindings.LDKBaseSign BaseSign, ChannelPublicKeys pubkeys) {
- super(bindings.LDKSign_new(arg, BaseSign, pubkeys == null ? 0 : pubkeys.ptr & ~1));
+ super(bindings.LDKSign_new(arg, BaseSign, pubkeys == null ? 0 : pubkeys.clone_ptr()));
this.ptrs_to.add(arg);
this.ptrs_to.add(BaseSign);
this.bindings_instance = arg;
return ret;
}
+ long clone_ptr() {
+ long ret = bindings.Sign_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of a Sign
*/
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * An error occurred during signing
+ */
public final static class SignError extends SignOrCreationError {
private SignError(long ptr, bindings.LDKSignOrCreationError.SignError obj) {
super(null, ptr);
}
}
+ /**
+ * An error occurred while building the transaction
+ */
public final static class CreationError extends SignOrCreationError {
public final org.ldk.enums.CreationError creation_error;
private CreationError(long ptr, bindings.LDKSignOrCreationError.CreationError obj) {
this.creation_error = obj.creation_error;
}
}
+ long clone_ptr() {
+ long ret = bindings.SignOrCreationError_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the SignOrCreationError
*/
return ret;
}
+ long clone_ptr() {
+ long ret = bindings.SignedRawInvoice_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the SignedRawInvoice
*/
return ret;
}
+ long clone_ptr() {
+ long ret = bindings.SocketDescriptor_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of a SocketDescriptor
*/
assert false; return null; // Unreachable without extending the (internal) bindings interface
}
+ /**
+ * An output to a script which was provided via KeysInterface directly, either from
+ * `get_destination_script()` or `get_shutdown_scriptpubkey()`, thus you should already know
+ * how to spend it. No secret keys are provided as rust-lightning was never given any key.
+ * These may include outputs from a transaction punishing our counterparty or claiming an HTLC
+ * on-chain using the payment preimage or after it has timed out.
+ */
public final static class StaticOutput extends SpendableOutputDescriptor {
/**
* The outpoint which is spendable
this.output = output_conv;
}
}
+ /**
+ * An output to a P2WSH script which can be spent with a single signature after a CSV delay.
+ *
+ * The witness in the spending input should be:
+ * <BIP 143 signature> <empty vector> (MINIMALIF standard rule) <provided witnessScript>
+ *
+ * Note that the nSequence field in the spending input must be set to to_self_delay
+ * (which means the transaction is not broadcastable until at least to_self_delay
+ * blocks after the outpoint confirms).
+ *
+ * These are generally the result of a \"revocable\" output to us, spendable only by us unless
+ * it is an output from an old state which we broadcast (which should never happen).
+ *
+ * To derive the delayed_payment key which is used to sign for this input, you must pass the
+ * holder delayed_payment_base_key (ie the private key which corresponds to the pubkey in
+ * Sign::pubkeys().delayed_payment_basepoint) and the provided per_commitment_point to
+ * chan_utils::derive_private_key. The public key can be generated without the secret key
+ * using chan_utils::derive_public_key and only the delayed_payment_basepoint which appears in
+ * Sign::pubkeys().
+ *
+ * To derive the revocation_pubkey provided here (which is used in the witness
+ * script generation), you must pass the counterparty revocation_basepoint (which appears in the
+ * call to Sign::ready_channel) and the provided per_commitment point
+ * to chan_utils::derive_public_revocation_key.
+ *
+ * The witness script which is hashed and included in the output script_pubkey may be
+ * regenerated by passing the revocation_pubkey (derived as above), our delayed_payment pubkey
+ * (derived as above), and the to_self_delay contained here to
+ * chan_utils::get_revokeable_redeemscript.
+ */
public final static class DelayedPaymentOutput extends SpendableOutputDescriptor {
public final DelayedPaymentOutputDescriptor delayed_payment_output;
private DelayedPaymentOutput(long ptr, bindings.LDKSpendableOutputDescriptor.DelayedPaymentOutput obj) {
this.delayed_payment_output = delayed_payment_output_hu_conv;
}
}
+ /**
+ * An output to a P2WPKH, spendable exclusively by our payment key (ie the private key which
+ * corresponds to the public key in Sign::pubkeys().payment_point).
+ * The witness in the spending input, is, thus, simply:
+ * <BIP 143 signature> <payment key>
+ *
+ * These are generally the result of our counterparty having broadcast the current state,
+ * allowing us to claim the non-HTLC-encumbered outputs immediately.
+ */
public final static class StaticPaymentOutput extends SpendableOutputDescriptor {
public final StaticPaymentOutputDescriptor static_payment_output;
private StaticPaymentOutput(long ptr, bindings.LDKSpendableOutputDescriptor.StaticPaymentOutput obj) {
this.static_payment_output = static_payment_output_hu_conv;
}
}
+ long clone_ptr() {
+ long ret = bindings.SpendableOutputDescriptor_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the SpendableOutputDescriptor
*/
* the channel to spend the output.
*/
public void set_channel_keys_id(byte[] val) {
- bindings.StaticPaymentOutputDescriptor_set_channel_keys_id(this.ptr, val);
+ bindings.StaticPaymentOutputDescriptor_set_channel_keys_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* Constructs a new StaticPaymentOutputDescriptor given each field
*/
public static StaticPaymentOutputDescriptor of(OutPoint outpoint_arg, TxOut output_arg, byte[] channel_keys_id_arg, long channel_value_satoshis_arg) {
- long ret = bindings.StaticPaymentOutputDescriptor_new(outpoint_arg == null ? 0 : outpoint_arg.ptr & ~1, output_arg.ptr, channel_keys_id_arg, channel_value_satoshis_arg);
+ long ret = bindings.StaticPaymentOutputDescriptor_new(outpoint_arg == null ? 0 : outpoint_arg.ptr & ~1, output_arg.ptr, InternalUtils.check_arr_len(channel_keys_id_arg, 32), channel_value_satoshis_arg);
if (ret >= 0 && ret <= 4096) { return null; }
StaticPaymentOutputDescriptor ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new StaticPaymentOutputDescriptor(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.StaticPaymentOutputDescriptor_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the StaticPaymentOutputDescriptor
*/
if (ptr != 0) { bindings.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(ptr); }
}
+ /**
+ *
+ */
+ public ChannelAnnouncement get_a() {
+ long ret = bindings.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(this.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ ChannelAnnouncement ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new ChannelAnnouncement(null, ret); }
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+ /**
+ *
+ */
+ public ChannelUpdate get_b() {
+ long ret = bindings.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(this.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ ChannelUpdate ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new ChannelUpdate(null, ret); }
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+ /**
+ *
+ */
+ public ChannelUpdate get_c() {
+ long ret = bindings.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(this.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ ChannelUpdate ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new ChannelUpdate(null, ret); }
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
+ /**
+ * Creates a new tuple which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
+ */
+ public ThreeTuple_ChannelAnnouncementChannelUpdateChannelUpdateZ clone() {
+ long ret = bindings.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(this.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ ThreeTuple_ChannelAnnouncementChannelUpdateChannelUpdateZ ret_hu_conv = new ThreeTuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(null, ret);
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+ /**
+ * Creates a new C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ from the contained elements.
+ */
+ public static ThreeTuple_ChannelAnnouncementChannelUpdateChannelUpdateZ of(ChannelAnnouncement a, ChannelUpdate b, ChannelUpdate c) {
+ long ret = bindings.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a == null ? 0 : a.ptr & ~1, b == null ? 0 : b.ptr & ~1, c == null ? 0 : c.ptr & ~1);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ ThreeTuple_ChannelAnnouncementChannelUpdateChannelUpdateZ ret_hu_conv = new ThreeTuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(null, ret);
+ ret_hu_conv.ptrs_to.add(ret_hu_conv);
+ return ret_hu_conv;
+ }
+
}
if (ptr != 0) { bindings.C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(ptr); }
}
+ /**
+ *
+ */
+ public RawInvoice get_a() {
+ long ret = bindings.C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(this.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ RawInvoice ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new RawInvoice(null, ret); }
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+ /**
+ *
+ */
+ public byte[] get_b() {
+ byte[] ret = bindings.C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(this.ptr);
+ return ret;
+ }
+
+ /**
+ *
+ */
+ public InvoiceSignature get_c() {
+ long ret = bindings.C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(this.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ InvoiceSignature ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new InvoiceSignature(null, ret); }
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+ long clone_ptr() {
+ long ret = bindings.C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
+ /**
+ * Creates a new tuple which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
+ */
+ public ThreeTuple_RawInvoice_u832InvoiceSignatureZ clone() {
+ long ret = bindings.C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(this.ptr);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ ThreeTuple_RawInvoice_u832InvoiceSignatureZ ret_hu_conv = new ThreeTuple_RawInvoice_u832InvoiceSignatureZ(null, ret);
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+ /**
+ * Creates a new C3Tuple_RawInvoice_u832InvoiceSignatureZ from the contained elements.
+ */
+ public static ThreeTuple_RawInvoice_u832InvoiceSignatureZ of(RawInvoice a, byte[] b, InvoiceSignature c) {
+ long ret = bindings.C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a == null ? 0 : a.ptr & ~1, InternalUtils.check_arr_len(b, 32), c == null ? 0 : c.ptr & ~1);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ ThreeTuple_RawInvoice_u832InvoiceSignatureZ ret_hu_conv = new ThreeTuple_RawInvoice_u832InvoiceSignatureZ(null, ret);
+ ret_hu_conv.ptrs_to.add(ret_hu_conv);
+ return ret_hu_conv;
+ }
+
}
* because we are about to broadcast a holder transaction.
*/
public byte[] sign(byte[] funding_key, byte[] funding_redeemscript, long channel_value_satoshis) {
- byte[] ret = bindings.TrustedClosingTransaction_sign(this.ptr, funding_key, funding_redeemscript, channel_value_satoshis);
+ byte[] ret = bindings.TrustedClosingTransaction_sign(this.ptr, InternalUtils.check_arr_len(funding_key, 32), funding_redeemscript, channel_value_satoshis);
return ret;
}
* The returned Vec has one entry for each HTLC, and in the same order.
*/
public Result_CVec_SignatureZNoneZ get_htlc_sigs(byte[] htlc_base_key, DirectedChannelTransactionParameters channel_parameters) {
- long ret = bindings.TrustedCommitmentTransaction_get_htlc_sigs(this.ptr, htlc_base_key, channel_parameters == null ? 0 : channel_parameters.ptr & ~1);
+ long ret = bindings.TrustedCommitmentTransaction_get_htlc_sigs(this.ptr, InternalUtils.check_arr_len(htlc_base_key, 32), channel_parameters == null ? 0 : channel_parameters.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
Result_CVec_SignatureZNoneZ ret_hu_conv = Result_CVec_SignatureZNoneZ.constr_from_ptr(ret);
this.ptrs_to.add(channel_parameters);
* Creates a new C2Tuple_BlockHashChannelManagerZ from the contained elements.
*/
public static TwoTuple_BlockHashChannelManagerZ of(byte[] a, FeeEstimator b_fee_est, Watch b_chain_monitor, BroadcasterInterface b_tx_broadcaster, Logger b_logger, KeysInterface b_keys_manager, UserConfig b_config, ChainParameters b_params) {
- long ret = bindings.C2Tuple_BlockHashChannelManagerZ_new(a, bindings.ChannelManager_new(b_fee_est == null ? 0 : b_fee_est.ptr, b_chain_monitor == null ? 0 : b_chain_monitor.ptr, b_tx_broadcaster == null ? 0 : b_tx_broadcaster.ptr, b_logger == null ? 0 : b_logger.ptr, b_keys_manager == null ? 0 : b_keys_manager.ptr, b_config == null ? 0 : b_config.ptr & ~1, b_params == null ? 0 : b_params.ptr & ~1));
+ long ret = bindings.C2Tuple_BlockHashChannelManagerZ_new(InternalUtils.check_arr_len(a, 32), bindings.ChannelManager_new(b_fee_est == null ? 0 : b_fee_est.ptr, b_chain_monitor == null ? 0 : b_chain_monitor.ptr, b_tx_broadcaster == null ? 0 : b_tx_broadcaster.ptr, b_logger == null ? 0 : b_logger.ptr, b_keys_manager == null ? 0 : b_keys_manager.ptr, b_config == null ? 0 : b_config.ptr & ~1, b_params == null ? 0 : b_params.ptr & ~1));
if (ret >= 0 && ret <= 4096) { return null; }
TwoTuple_BlockHashChannelManagerZ ret_hu_conv = new TwoTuple_BlockHashChannelManagerZ(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.C2Tuple_BlockHashChannelMonitorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new tuple which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
* Creates a new C2Tuple_BlockHashChannelMonitorZ from the contained elements.
*/
public static TwoTuple_BlockHashChannelMonitorZ of(byte[] a, ChannelMonitor b) {
- long ret = bindings.C2Tuple_BlockHashChannelMonitorZ_new(a, b == null ? 0 : b.ptr & ~1);
+ long ret = bindings.C2Tuple_BlockHashChannelMonitorZ_new(InternalUtils.check_arr_len(a, 32), b == null ? 0 : b.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
TwoTuple_BlockHashChannelMonitorZ ret_hu_conv = new TwoTuple_BlockHashChannelMonitorZ(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret;
}
+ long clone_ptr() {
+ long ret = bindings.C2Tuple_OutPointScriptZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new tuple which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
return ret;
}
+ long clone_ptr() {
+ long ret = bindings.C2Tuple_PaymentHashPaymentIdZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new tuple which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
* Creates a new C2Tuple_PaymentHashPaymentIdZ from the contained elements.
*/
public static TwoTuple_PaymentHashPaymentIdZ of(byte[] a, byte[] b) {
- long ret = bindings.C2Tuple_PaymentHashPaymentIdZ_new(a, b);
+ long ret = bindings.C2Tuple_PaymentHashPaymentIdZ_new(InternalUtils.check_arr_len(a, 32), InternalUtils.check_arr_len(b, 32));
if (ret >= 0 && ret <= 4096) { return null; }
TwoTuple_PaymentHashPaymentIdZ ret_hu_conv = new TwoTuple_PaymentHashPaymentIdZ(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret;
}
+ long clone_ptr() {
+ long ret = bindings.C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new tuple which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
* Creates a new C2Tuple_PaymentHashPaymentSecretZ from the contained elements.
*/
public static TwoTuple_PaymentHashPaymentSecretZ of(byte[] a, byte[] b) {
- long ret = bindings.C2Tuple_PaymentHashPaymentSecretZ_new(a, b);
+ long ret = bindings.C2Tuple_PaymentHashPaymentSecretZ_new(InternalUtils.check_arr_len(a, 32), InternalUtils.check_arr_len(b, 32));
if (ret >= 0 && ret <= 4096) { return null; }
TwoTuple_PaymentHashPaymentSecretZ ret_hu_conv = new TwoTuple_PaymentHashPaymentSecretZ(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.C2Tuple_PublicKeyTypeZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new tuple which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
* Creates a new C2Tuple_PublicKeyTypeZ from the contained elements.
*/
public static TwoTuple_PublicKeyTypeZ of(byte[] a, Type b) {
- long ret = bindings.C2Tuple_PublicKeyTypeZ_new(a, b == null ? 0 : b.ptr);
+ long ret = bindings.C2Tuple_PublicKeyTypeZ_new(InternalUtils.check_arr_len(a, 33), b == null ? 0 : b.ptr);
if (ret >= 0 && ret <= 4096) { return null; }
TwoTuple_PublicKeyTypeZ ret_hu_conv = new TwoTuple_PublicKeyTypeZ(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret;
}
+ long clone_ptr() {
+ long ret = bindings.C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new tuple which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
* Creates a new C2Tuple_SignatureCVec_SignatureZZ from the contained elements.
*/
public static TwoTuple_SignatureCVec_SignatureZZ of(byte[] a, byte[][] b) {
- long ret = bindings.C2Tuple_SignatureCVec_SignatureZZ_new(a, b);
+ long ret = bindings.C2Tuple_SignatureCVec_SignatureZZ_new(InternalUtils.check_arr_len(a, 64), b != null ? Arrays.stream(b).map(b_conv_8 -> InternalUtils.check_arr_len(b_conv_8, 64)).toArray(byte[][]::new) : null);
if (ret >= 0 && ret <= 4096) { return null; }
TwoTuple_SignatureCVec_SignatureZZ ret_hu_conv = new TwoTuple_SignatureCVec_SignatureZZ(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_conv_21_arr;
}
+ long clone_ptr() {
+ long ret = bindings.C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new tuple which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
* Creates a new C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ from the contained elements.
*/
public static TwoTuple_TxidCVec_C2Tuple_u32ScriptZZZ of(byte[] a, TwoTuple_u32ScriptZ[] b) {
- long ret = bindings.C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a, b != null ? Arrays.stream(b).mapToLong(b_conv_21 -> b_conv_21 != null ? b_conv_21.ptr : 0).toArray() : null);
+ long ret = bindings.C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(InternalUtils.check_arr_len(a, 32), b != null ? Arrays.stream(b).mapToLong(b_conv_21 -> b_conv_21 != null ? b_conv_21.ptr : 0).toArray() : null);
if (ret >= 0 && ret <= 4096) { return null; }
TwoTuple_TxidCVec_C2Tuple_u32ScriptZZZ ret_hu_conv = new TwoTuple_TxidCVec_C2Tuple_u32ScriptZZZ(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_conv_20_arr;
}
+ long clone_ptr() {
+ long ret = bindings.C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new tuple which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
* Creates a new C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ from the contained elements.
*/
public static TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ of(byte[] a, TwoTuple_u32TxOutZ[] b) {
- long ret = bindings.C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a, b != null ? Arrays.stream(b).mapToLong(b_conv_20 -> b_conv_20 != null ? b_conv_20.ptr : 0).toArray() : null);
+ long ret = bindings.C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(InternalUtils.check_arr_len(a, 32), b != null ? Arrays.stream(b).mapToLong(b_conv_20 -> b_conv_20 != null ? b_conv_20.ptr : 0).toArray() : null);
if (ret >= 0 && ret <= 4096) { return null; }
TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ ret_hu_conv = new TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret;
}
+ long clone_ptr() {
+ long ret = bindings.C2Tuple_u32ScriptZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new tuple which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
return ret_conv;
}
+ long clone_ptr() {
+ long ret = bindings.C2Tuple_u32TxOutZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new tuple which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
return ret;
}
+ long clone_ptr() {
+ long ret = bindings.C2Tuple_usizeTransactionZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a new tuple which has the same data as `orig`
* but with all dynamically-allocated buffers duplicated in new buffers.
* The broadcaster's per-commitment public key which was used to derive the other keys.
*/
public void set_per_commitment_point(byte[] val) {
- bindings.TxCreationKeys_set_per_commitment_point(this.ptr, val);
+ bindings.TxCreationKeys_set_per_commitment_point(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* an old state.
*/
public void set_revocation_key(byte[] val) {
- bindings.TxCreationKeys_set_revocation_key(this.ptr, val);
+ bindings.TxCreationKeys_set_revocation_key(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* Broadcaster's HTLC Key
*/
public void set_broadcaster_htlc_key(byte[] val) {
- bindings.TxCreationKeys_set_broadcaster_htlc_key(this.ptr, val);
+ bindings.TxCreationKeys_set_broadcaster_htlc_key(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* Countersignatory's HTLC Key
*/
public void set_countersignatory_htlc_key(byte[] val) {
- bindings.TxCreationKeys_set_countersignatory_htlc_key(this.ptr, val);
+ bindings.TxCreationKeys_set_countersignatory_htlc_key(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* Broadcaster's Payment Key (which isn't allowed to be spent from for some delay)
*/
public void set_broadcaster_delayed_payment_key(byte[] val) {
- bindings.TxCreationKeys_set_broadcaster_delayed_payment_key(this.ptr, val);
+ bindings.TxCreationKeys_set_broadcaster_delayed_payment_key(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* Constructs a new TxCreationKeys given each field
*/
public static TxCreationKeys of(byte[] per_commitment_point_arg, byte[] revocation_key_arg, byte[] broadcaster_htlc_key_arg, byte[] countersignatory_htlc_key_arg, byte[] broadcaster_delayed_payment_key_arg) {
- long ret = bindings.TxCreationKeys_new(per_commitment_point_arg, revocation_key_arg, broadcaster_htlc_key_arg, countersignatory_htlc_key_arg, broadcaster_delayed_payment_key_arg);
+ long ret = bindings.TxCreationKeys_new(InternalUtils.check_arr_len(per_commitment_point_arg, 33), InternalUtils.check_arr_len(revocation_key_arg, 33), InternalUtils.check_arr_len(broadcaster_htlc_key_arg, 33), InternalUtils.check_arr_len(countersignatory_htlc_key_arg, 33), InternalUtils.check_arr_len(broadcaster_delayed_payment_key_arg, 33));
if (ret >= 0 && ret <= 4096) { return null; }
TxCreationKeys ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new TxCreationKeys(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.TxCreationKeys_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the TxCreationKeys
*/
* Key set is asymmetric and can't be used as part of counter-signatory set of transactions.
*/
public static Result_TxCreationKeysErrorZ derive_new(byte[] per_commitment_point, byte[] broadcaster_delayed_payment_base, byte[] broadcaster_htlc_base, byte[] countersignatory_revocation_base, byte[] countersignatory_htlc_base) {
- long ret = bindings.TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
+ long ret = bindings.TxCreationKeys_derive_new(InternalUtils.check_arr_len(per_commitment_point, 33), InternalUtils.check_arr_len(broadcaster_delayed_payment_base, 33), InternalUtils.check_arr_len(broadcaster_htlc_base, 33), InternalUtils.check_arr_len(countersignatory_revocation_base, 33), InternalUtils.check_arr_len(countersignatory_htlc_base, 33));
if (ret >= 0 && ret <= 4096) { return null; }
Result_TxCreationKeysErrorZ ret_hu_conv = Result_TxCreationKeysErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
* Key set is asymmetric and can't be used as part of counter-signatory set of transactions.
*/
public static Result_TxCreationKeysErrorZ from_channel_static_keys(byte[] per_commitment_point, ChannelPublicKeys broadcaster_keys, ChannelPublicKeys countersignatory_keys) {
- long ret = bindings.TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys == null ? 0 : broadcaster_keys.ptr & ~1, countersignatory_keys == null ? 0 : countersignatory_keys.ptr & ~1);
+ long ret = bindings.TxCreationKeys_from_channel_static_keys(InternalUtils.check_arr_len(per_commitment_point, 33), broadcaster_keys == null ? 0 : broadcaster_keys.ptr & ~1, countersignatory_keys == null ? 0 : countersignatory_keys.ptr & ~1);
if (ret >= 0 && ret <= 4096) { return null; }
Result_TxCreationKeysErrorZ ret_hu_conv = Result_TxCreationKeysErrorZ.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(broadcaster_keys);
return ret;
}
+ long clone_ptr() {
+ long ret = bindings.Type_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of a Type
*/
* The genesis hash of the blockchain where the channel is to be opened
*/
public void set_chain_hash(byte[] val) {
- bindings.UnsignedChannelAnnouncement_set_chain_hash(this.ptr, val);
+ bindings.UnsignedChannelAnnouncement_set_chain_hash(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* One of the two node_ids which are endpoints of this channel
*/
public void set_node_id_1(byte[] val) {
- bindings.UnsignedChannelAnnouncement_set_node_id_1(this.ptr, val);
+ bindings.UnsignedChannelAnnouncement_set_node_id_1(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* The other of the two node_ids which are endpoints of this channel
*/
public void set_node_id_2(byte[] val) {
- bindings.UnsignedChannelAnnouncement_set_node_id_2(this.ptr, val);
+ bindings.UnsignedChannelAnnouncement_set_node_id_2(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* The funding key for the first node
*/
public void set_bitcoin_key_1(byte[] val) {
- bindings.UnsignedChannelAnnouncement_set_bitcoin_key_1(this.ptr, val);
+ bindings.UnsignedChannelAnnouncement_set_bitcoin_key_1(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* The funding key for the second node
*/
public void set_bitcoin_key_2(byte[] val) {
- bindings.UnsignedChannelAnnouncement_set_bitcoin_key_2(this.ptr, val);
+ bindings.UnsignedChannelAnnouncement_set_bitcoin_key_2(this.ptr, InternalUtils.check_arr_len(val, 33));
+ }
+
+ long clone_ptr() {
+ long ret = bindings.UnsignedChannelAnnouncement_clone_ptr(this.ptr);
+ return ret;
}
/**
* The genesis hash of the blockchain where the channel is to be opened
*/
public void set_chain_hash(byte[] val) {
- bindings.UnsignedChannelUpdate_set_chain_hash(this.ptr, val);
+ bindings.UnsignedChannelUpdate_set_chain_hash(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
bindings.UnsignedChannelUpdate_set_fee_proportional_millionths(this.ptr, val);
}
+ long clone_ptr() {
+ long ret = bindings.UnsignedChannelUpdate_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the UnsignedChannelUpdate
*/
* to this node).
*/
public void set_node_id(byte[] val) {
- bindings.UnsignedNodeAnnouncement_set_node_id(this.ptr, val);
+ bindings.UnsignedNodeAnnouncement_set_node_id(this.ptr, InternalUtils.check_arr_len(val, 33));
}
/**
* An RGB color for UI purposes
*/
public void set_rgb(byte[] val) {
- bindings.UnsignedNodeAnnouncement_set_rgb(this.ptr, val);
+ bindings.UnsignedNodeAnnouncement_set_rgb(this.ptr, InternalUtils.check_arr_len(val, 3));
}
/**
* of uniqueness.
*/
public void set_alias(byte[] val) {
- bindings.UnsignedNodeAnnouncement_set_alias(this.ptr, val);
+ bindings.UnsignedNodeAnnouncement_set_alias(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
bindings.UnsignedNodeAnnouncement_set_addresses(this.ptr, val != null ? Arrays.stream(val).mapToLong(val_conv_12 -> val_conv_12.ptr).toArray() : null);
}
+ long clone_ptr() {
+ long ret = bindings.UnsignedNodeAnnouncement_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the UnsignedNodeAnnouncement
*/
* The channel ID
*/
public void set_channel_id(byte[] val) {
- bindings.UpdateAddHTLC_set_channel_id(this.ptr, val);
+ bindings.UpdateAddHTLC_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* The payment hash, the pre-image of which controls HTLC redemption
*/
public void set_payment_hash(byte[] val) {
- bindings.UpdateAddHTLC_set_payment_hash(this.ptr, val);
+ bindings.UpdateAddHTLC_set_payment_hash(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
bindings.UpdateAddHTLC_set_cltv_expiry(this.ptr, val);
}
+ long clone_ptr() {
+ long ret = bindings.UpdateAddHTLC_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the UpdateAddHTLC
*/
* The channel ID
*/
public void set_channel_id(byte[] val) {
- bindings.UpdateFailHTLC_set_channel_id(this.ptr, val);
+ bindings.UpdateFailHTLC_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
bindings.UpdateFailHTLC_set_htlc_id(this.ptr, val);
}
+ long clone_ptr() {
+ long ret = bindings.UpdateFailHTLC_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the UpdateFailHTLC
*/
* The channel ID
*/
public void set_channel_id(byte[] val) {
- bindings.UpdateFailMalformedHTLC_set_channel_id(this.ptr, val);
+ bindings.UpdateFailMalformedHTLC_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
bindings.UpdateFailMalformedHTLC_set_failure_code(this.ptr, val);
}
+ long clone_ptr() {
+ long ret = bindings.UpdateFailMalformedHTLC_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the UpdateFailMalformedHTLC
*/
* The channel ID
*/
public void set_channel_id(byte[] val) {
- bindings.UpdateFee_set_channel_id(this.ptr, val);
+ bindings.UpdateFee_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* Constructs a new UpdateFee given each field
*/
public static UpdateFee of(byte[] channel_id_arg, int feerate_per_kw_arg) {
- long ret = bindings.UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
+ long ret = bindings.UpdateFee_new(InternalUtils.check_arr_len(channel_id_arg, 32), feerate_per_kw_arg);
if (ret >= 0 && ret <= 4096) { return null; }
UpdateFee ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new UpdateFee(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.UpdateFee_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the UpdateFee
*/
* The channel ID
*/
public void set_channel_id(byte[] val) {
- bindings.UpdateFulfillHTLC_set_channel_id(this.ptr, val);
+ bindings.UpdateFulfillHTLC_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* The pre-image of the payment hash, allowing HTLC redemption
*/
public void set_payment_preimage(byte[] val) {
- bindings.UpdateFulfillHTLC_set_payment_preimage(this.ptr, val);
+ bindings.UpdateFulfillHTLC_set_payment_preimage(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* Constructs a new UpdateFulfillHTLC given each field
*/
public static UpdateFulfillHTLC of(byte[] channel_id_arg, long htlc_id_arg, byte[] payment_preimage_arg) {
- long ret = bindings.UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
+ long ret = bindings.UpdateFulfillHTLC_new(InternalUtils.check_arr_len(channel_id_arg, 32), htlc_id_arg, InternalUtils.check_arr_len(payment_preimage_arg, 32));
if (ret >= 0 && ret <= 4096) { return null; }
UpdateFulfillHTLC ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new UpdateFulfillHTLC(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.UpdateFulfillHTLC_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the UpdateFulfillHTLC
*/
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.UserConfig_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the UserConfig
*/
package org.ldk.structs;
import org.ldk.impl.bindings;
+import org.ldk.enums.*;
+import org.ldk.util.*;
import java.util.Arrays;
import javax.annotation.Nullable;
-import org.ldk.enums.*;
public class UtilMethods {
+ /**
+ * Read a ClosureReason from a byte array, created by ClosureReason_write
+ */
+ public static Result_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(byte[] ser) {
+ long ret = bindings.ClosureReason_read(ser);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Result_COption_ClosureReasonZDecodeErrorZ ret_hu_conv = Result_COption_ClosureReasonZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ /**
+ * Read a Event from a byte array, created by Event_write
+ */
+ public static Result_COption_EventZDecodeErrorZ Event_read(byte[] ser) {
+ long ret = bindings.Event_read(ser);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Result_COption_EventZDecodeErrorZ ret_hu_conv = Result_COption_EventZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
/**
* Creates a digital signature of a message given a SecretKey, like the node's secret.
* A receiver knowing the PublicKey (e.g. the node's id) and the message can be sure that the signature was generated by the caller.
* Signatures are EC recoverable, meaning that given the message and the signature the PublicKey of the signer can be extracted.
*/
public static Result_StringErrorZ sign(byte[] msg, byte[] sk) {
- long ret = bindings.sign(msg, sk);
+ long ret = bindings.sign(msg, InternalUtils.check_arr_len(sk, 32));
if (ret >= 0 && ret <= 4096) { return null; }
Result_StringErrorZ ret_hu_conv = Result_StringErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
* and the PublicKey.
*/
public static boolean verify(byte[] msg, java.lang.String sig, byte[] pk) {
- boolean ret = bindings.verify(msg, sig, pk);
+ boolean ret = bindings.verify(msg, sig, InternalUtils.check_arr_len(pk, 33));
return ret;
}
+ /**
+ * Read a MonitorEvent from a byte array, created by MonitorEvent_write
+ */
+ public static Result_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(byte[] ser) {
+ long ret = bindings.MonitorEvent_read(ser);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Result_COption_MonitorEventZDecodeErrorZ ret_hu_conv = Result_COption_MonitorEventZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
/**
* Read a C2Tuple_BlockHashChannelMonitorZ from a byte array, created by C2Tuple_BlockHashChannelMonitorZ_write
*/
* Build the commitment secret from the seed and the commitment number
*/
public static byte[] build_commitment_secret(byte[] commitment_seed, long idx) {
- byte[] ret = bindings.build_commitment_secret(commitment_seed, idx);
+ byte[] ret = bindings.build_commitment_secret(InternalUtils.check_arr_len(commitment_seed, 32), idx);
return ret;
}
* generated (ie our own).
*/
public static Result_SecretKeyErrorZ derive_private_key(byte[] per_commitment_point, byte[] base_secret) {
- long ret = bindings.derive_private_key(per_commitment_point, base_secret);
+ long ret = bindings.derive_private_key(InternalUtils.check_arr_len(per_commitment_point, 33), InternalUtils.check_arr_len(base_secret, 32));
if (ret >= 0 && ret <= 4096) { return null; }
Result_SecretKeyErrorZ ret_hu_conv = Result_SecretKeyErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
* generated (ie our own).
*/
public static Result_PublicKeyErrorZ derive_public_key(byte[] per_commitment_point, byte[] base_point) {
- long ret = bindings.derive_public_key(per_commitment_point, base_point);
+ long ret = bindings.derive_public_key(InternalUtils.check_arr_len(per_commitment_point, 33), InternalUtils.check_arr_len(base_point, 33));
if (ret >= 0 && ret <= 4096) { return null; }
Result_PublicKeyErrorZ ret_hu_conv = Result_PublicKeyErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
* generated (ie our own).
*/
public static Result_SecretKeyErrorZ derive_private_revocation_key(byte[] per_commitment_secret, byte[] countersignatory_revocation_base_secret) {
- long ret = bindings.derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
+ long ret = bindings.derive_private_revocation_key(InternalUtils.check_arr_len(per_commitment_secret, 32), InternalUtils.check_arr_len(countersignatory_revocation_base_secret, 32));
if (ret >= 0 && ret <= 4096) { return null; }
Result_SecretKeyErrorZ ret_hu_conv = Result_SecretKeyErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
* generated (ie our own).
*/
public static Result_PublicKeyErrorZ derive_public_revocation_key(byte[] per_commitment_point, byte[] countersignatory_revocation_base_point) {
- long ret = bindings.derive_public_revocation_key(per_commitment_point, countersignatory_revocation_base_point);
+ long ret = bindings.derive_public_revocation_key(InternalUtils.check_arr_len(per_commitment_point, 33), InternalUtils.check_arr_len(countersignatory_revocation_base_point, 33));
if (ret >= 0 && ret <= 4096) { return null; }
Result_PublicKeyErrorZ ret_hu_conv = Result_PublicKeyErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
* Encumbering a `to_holder` output on a commitment transaction or 2nd-stage HTLC transactions.
*/
public static byte[] get_revokeable_redeemscript(byte[] revocation_key, short contest_delay, byte[] broadcaster_delayed_payment_key) {
- byte[] ret = bindings.get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
+ byte[] ret = bindings.get_revokeable_redeemscript(InternalUtils.check_arr_len(revocation_key, 33), contest_delay, InternalUtils.check_arr_len(broadcaster_delayed_payment_key, 33));
return ret;
}
* Note that the order of funding public keys does not matter.
*/
public static byte[] make_funding_redeemscript(byte[] broadcaster, byte[] countersignatory) {
- byte[] ret = bindings.make_funding_redeemscript(broadcaster, countersignatory);
+ byte[] ret = bindings.make_funding_redeemscript(InternalUtils.check_arr_len(broadcaster, 33), InternalUtils.check_arr_len(countersignatory, 33));
return ret;
}
* commitment transaction).
*/
public static byte[] build_htlc_transaction(byte[] commitment_txid, int feerate_per_kw, short contest_delay, HTLCOutputInCommitment htlc, byte[] broadcaster_delayed_payment_key, byte[] revocation_key) {
- byte[] ret = bindings.build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc == null ? 0 : htlc.ptr & ~1, broadcaster_delayed_payment_key, revocation_key);
+ byte[] ret = bindings.build_htlc_transaction(InternalUtils.check_arr_len(commitment_txid, 32), feerate_per_kw, contest_delay, htlc == null ? 0 : htlc.ptr & ~1, InternalUtils.check_arr_len(broadcaster_delayed_payment_key, 33), InternalUtils.check_arr_len(revocation_key, 33));
// this.ptrs_to.add(htlc);
return ret;
}
* \"decrypt\" the commitment transaction number given a commitment transaction on-chain.
*/
public static long get_commitment_transaction_number_obscure_factor(byte[] broadcaster_payment_basepoint, byte[] countersignatory_payment_basepoint, boolean outbound_from_broadcaster) {
- long ret = bindings.get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
+ long ret = bindings.get_commitment_transaction_number_obscure_factor(InternalUtils.check_arr_len(broadcaster_payment_basepoint, 33), InternalUtils.check_arr_len(countersignatory_payment_basepoint, 33), outbound_from_broadcaster);
return ret;
}
+ /**
+ * Read a NetworkUpdate from a byte array, created by NetworkUpdate_write
+ */
+ public static Result_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(byte[] ser) {
+ long ret = bindings.NetworkUpdate_read(ser);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Result_COption_NetworkUpdateZDecodeErrorZ ret_hu_conv = Result_COption_NetworkUpdateZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
/**
* Finds a route from us (payer) to the given target node (payee).
*
* Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
*/
public static Result_RouteLightningErrorZ find_route(byte[] our_node_pubkey, RouteParameters params, NetworkGraph network, @Nullable ChannelDetails[] first_hops, Logger logger, Score scorer) {
- long ret = bindings.find_route(our_node_pubkey, params == null ? 0 : params.ptr & ~1, network == null ? 0 : network.ptr & ~1, first_hops != null ? Arrays.stream(first_hops).mapToLong(first_hops_conv_16 -> first_hops_conv_16 == null ? 0 : first_hops_conv_16.ptr & ~1).toArray() : null, logger == null ? 0 : logger.ptr, scorer == null ? 0 : scorer.ptr);
+ long ret = bindings.find_route(InternalUtils.check_arr_len(our_node_pubkey, 33), params == null ? 0 : params.ptr & ~1, network == null ? 0 : network.ptr & ~1, first_hops != null ? Arrays.stream(first_hops).mapToLong(first_hops_conv_16 -> first_hops_conv_16 == null ? 0 : first_hops_conv_16.ptr & ~1).toArray() : null, logger == null ? 0 : logger.ptr, scorer == null ? 0 : scorer.ptr);
if (ret >= 0 && ret <= 4096) { return null; }
Result_RouteLightningErrorZ ret_hu_conv = Result_RouteLightningErrorZ.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(params);
ChannelMonitor monitor_hu_conv = null; if (monitor < 0 || monitor > 4096) { monitor_hu_conv = new ChannelMonitor(null, monitor); }
monitor_hu_conv.ptrs_to.add(this);
Result_NoneChannelMonitorUpdateErrZ ret = arg.watch_channel(funding_txo_hu_conv, monitor_hu_conv);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
@Override public long update_channel(long funding_txo, long update) {
ChannelMonitorUpdate update_hu_conv = null; if (update < 0 || update > 4096) { update_hu_conv = new ChannelMonitorUpdate(null, update); }
update_hu_conv.ptrs_to.add(this);
Result_NoneChannelMonitorUpdateErrZ ret = arg.update_channel(funding_txo_hu_conv, update_hu_conv);
- long result = ret != null ? ret.ptr : 0;
+ long result = ret == null ? 0 : ret.clone_ptr();
return result;
}
@Override public long[] release_pending_monitor_events() {
MonitorEvent[] ret = arg.release_pending_monitor_events();
- long[] result = ret != null ? Arrays.stream(ret).mapToLong(ret_conv_14 -> ret_conv_14.ptr).toArray() : null;
+ long[] result = ret != null ? Arrays.stream(ret).mapToLong(ret_conv_14 -> ret_conv_14 == null ? 0 : ret_conv_14.clone_ptr()).toArray() : null;
return result;
}
});
* Note that val (or a relevant inner pointer) may be NULL or all-0s to represent None
*/
public void set_block_hash(@Nullable byte[] val) {
- bindings.WatchedOutput_set_block_hash(this.ptr, val);
+ bindings.WatchedOutput_set_block_hash(this.ptr, InternalUtils.check_arr_len(val, 32));
}
/**
* Constructs a new WatchedOutput given each field
*/
public static WatchedOutput of(byte[] block_hash_arg, OutPoint outpoint_arg, byte[] script_pubkey_arg) {
- long ret = bindings.WatchedOutput_new(block_hash_arg, outpoint_arg == null ? 0 : outpoint_arg.ptr & ~1, script_pubkey_arg);
+ long ret = bindings.WatchedOutput_new(InternalUtils.check_arr_len(block_hash_arg, 32), outpoint_arg == null ? 0 : outpoint_arg.ptr & ~1, script_pubkey_arg);
if (ret >= 0 && ret <= 4096) { return null; }
WatchedOutput ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new WatchedOutput(null, ret); }
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ long clone_ptr() {
+ long ret = bindings.WatchedOutput_clone_ptr(this.ptr);
+ return ret;
+ }
+
/**
* Creates a copy of the WatchedOutput
*/
--- /dev/null
+package org.ldk.util;
+
+public class InternalUtils {
+ public static byte[] check_arr_len(byte[] arr, int length) throws IllegalArgumentException {
+ if (arr.length != length) {
+ throw new IllegalArgumentException("Array must be of fixed size " + length + " but was of length " + arr.length);
+ }
+ return arr;
+ }
+}
#define MALLOC(a, _) malloc(a)
#define FREE(p) if ((uint64_t)(p) > 4096) { free(p); }
#define CHECK_ACCESS(p)
+#define CHECK_INNER_FIELD_ACCESS_OR_NULL(v)
#define DO_ASSERT(a) (void)(a)
#define CHECK(a)
}
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1u8Z_1new(JNIEnv *env, jclass clz, int8_tArray elems) {
- LDKCVec_u8Z *ret = MALLOC(sizeof(LDKCVec_u8Z), "LDKCVec_u8Z");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(uint8_t) * ret->datalen, "LDKCVec_u8Z Data");
- int8_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- ret->data[i] = java_elems[i];
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_u8Z CVec_u8Z_clone(const LDKCVec_u8Z *orig) {
LDKCVec_u8Z ret = { .data = MALLOC(sizeof(int8_t) * orig->datalen, "LDKCVec_u8Z clone bytes"), .datalen = orig->datalen };
memcpy(ret.data, orig->data, sizeof(int8_t) * ret.datalen);
return ret_val;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SecretKeyErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_SecretKeyErrorZ*)arg)->result_ok;
-}
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SecretKeyErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_SecretKeyErrorZ *val = (LDKCResult_SecretKeyErrorZ*)(arg & ~1);
CHECK(val->result_ok);
jclass err_conv = LDKSecp256k1Error_to_java(env, (*val->contents.err));
return err_conv;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PublicKeyErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_PublicKeyErrorZ*)arg)->result_ok;
-}
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PublicKeyErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_PublicKeyErrorZ *val = (LDKCResult_PublicKeyErrorZ*)(arg & ~1);
CHECK(val->result_ok);
jclass err_conv = LDKSecp256k1Error_to_java(env, (*val->contents.err));
return err_conv;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_TxCreationKeysDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_TxCreationKeysDecodeErrorZ *val = (LDKCResult_TxCreationKeysDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelPublicKeysDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ChannelPublicKeysDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelPublicKeysDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ChannelPublicKeysDecodeErrorZ *val = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_TxCreationKeysErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_TxCreationKeysErrorZ *val = (LDKCResult_TxCreationKeysErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
default: abort();
}
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCOutputInCommitmentDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCOutputInCommitmentDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *val = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *val = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelTransactionParametersDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ChannelTransactionParametersDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelTransactionParametersDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ChannelTransactionParametersDecodeErrorZ *val = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HolderCommitmentTransactionDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HolderCommitmentTransactionDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_HolderCommitmentTransactionDecodeErrorZ *val = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1BuiltCommitmentTransactionDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1BuiltCommitmentTransactionDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *val = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TrustedClosingTransactionNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_TrustedClosingTransactionNoneZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TrustedClosingTransactionNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_TrustedClosingTransactionNoneZ *val = (LDKCResult_TrustedClosingTransactionNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
CHECK(!val->result_ok);
return *val->contents.err;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentTransactionDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_CommitmentTransactionDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentTransactionDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_CommitmentTransactionDecodeErrorZ *val = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TrustedCommitmentTransactionNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_TrustedCommitmentTransactionNoneZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TrustedCommitmentTransactionNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_TrustedCommitmentTransactionNoneZ *val = (LDKCResult_TrustedCommitmentTransactionNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
CHECK(!val->result_ok);
return *val->contents.err;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1SignatureZNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_CVec_SignatureZNoneZ*)arg)->result_ok;
-}
JNIEXPORT jobjectArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1SignatureZNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_CVec_SignatureZNoneZ *val = (LDKCResult_CVec_SignatureZNoneZ*)(arg & ~1);
CHECK(val->result_ok);
CHECK(!val->result_ok);
return *val->contents.err;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownScriptDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ShutdownScriptDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownScriptDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ShutdownScriptDecodeErrorZ *val = (LDKCResult_ShutdownScriptDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownScriptInvalidShutdownScriptZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownScriptInvalidShutdownScriptZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ShutdownScriptInvalidShutdownScriptZ *val = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NoneErrorZ*)arg)->result_ok;
-}
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NoneErrorZ *val = (LDKCResult_NoneErrorZ*)(arg & ~1);
CHECK(val->result_ok);
jclass err_conv = LDKIOError_to_java(env, (*val->contents.err));
return err_conv;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteHopDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_RouteHopDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteHopDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_RouteHopDecodeErrorZ *val = (LDKCResult_RouteHopDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1RouteHopZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_RouteHopZ *ret = MALLOC(sizeof(LDKCVec_RouteHopZ), "LDKCVec_RouteHopZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKRouteHop) * ret->datalen, "LDKCVec_RouteHopZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKRouteHop arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = RouteHop_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_RouteHopZ CVec_RouteHopZ_clone(const LDKCVec_RouteHopZ *orig) {
LDKCVec_RouteHopZ ret = { .data = MALLOC(sizeof(LDKRouteHop) * orig->datalen, "LDKCVec_RouteHopZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_RouteDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_RouteDecodeErrorZ *val = (LDKCResult_RouteDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteParametersDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_RouteParametersDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteParametersDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_RouteParametersDecodeErrorZ *val = (LDKCResult_RouteParametersDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1RouteHintZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_RouteHintZ *ret = MALLOC(sizeof(LDKCVec_RouteHintZ), "LDKCVec_RouteHintZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKRouteHint) * ret->datalen, "LDKCVec_RouteHintZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKRouteHint arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = RouteHint_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_RouteHintZ CVec_RouteHintZ_clone(const LDKCVec_RouteHintZ *orig) {
LDKCVec_RouteHintZ ret = { .data = MALLOC(sizeof(LDKRouteHint) * orig->datalen, "LDKCVec_RouteHintZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
default: abort();
}
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PayeeDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_PayeeDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PayeeDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_PayeeDecodeErrorZ *val = (LDKCResult_PayeeDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1RouteHintHopZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_RouteHintHopZ *ret = MALLOC(sizeof(LDKCVec_RouteHintHopZ), "LDKCVec_RouteHintHopZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKRouteHintHop) * ret->datalen, "LDKCVec_RouteHintHopZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKRouteHintHop arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = RouteHintHop_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_RouteHintHopZ CVec_RouteHintHopZ_clone(const LDKCVec_RouteHintHopZ *orig) {
LDKCVec_RouteHintHopZ ret = { .data = MALLOC(sizeof(LDKRouteHintHop) * orig->datalen, "LDKCVec_RouteHintHopZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteHintDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_RouteHintDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteHintDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_RouteHintDecodeErrorZ *val = (LDKCResult_RouteHintDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteHintHopDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_RouteHintHopDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteHintHopDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_RouteHintHopDecodeErrorZ *val = (LDKCResult_RouteHintHopDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1ChannelDetailsZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_ChannelDetailsZ *ret = MALLOC(sizeof(LDKCVec_ChannelDetailsZ), "LDKCVec_ChannelDetailsZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKChannelDetails) * ret->datalen, "LDKCVec_ChannelDetailsZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKChannelDetails arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = ChannelDetails_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_ChannelDetailsZ CVec_ChannelDetailsZ_clone(const LDKCVec_ChannelDetailsZ *orig) {
LDKCVec_ChannelDetailsZ ret = { .data = MALLOC(sizeof(LDKChannelDetails) * orig->datalen, "LDKCVec_ChannelDetailsZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteLightningErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_RouteLightningErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteLightningErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_RouteLightningErrorZ *val = (LDKCResult_RouteLightningErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxOutAccessErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_TxOutAccessErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxOutAccessErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_TxOutAccessErrorZ *val = (LDKCResult_TxOutAccessErrorZ*)(arg & ~1);
CHECK(val->result_ok);
return ret_arr;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1usizeTransactionZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_C2Tuple_usizeTransactionZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_usizeTransactionZZ), "LDKCVec_C2Tuple_usizeTransactionZZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ) * ret->datalen, "LDKCVec_C2Tuple_usizeTransactionZZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_usizeTransactionZ arr_elem_conv = *(LDKC2Tuple_usizeTransactionZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_usizeTransactionZZ CVec_C2Tuple_usizeTransactionZZ_clone(const LDKCVec_C2Tuple_usizeTransactionZZ *orig) {
LDKCVec_C2Tuple_usizeTransactionZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ) * orig->datalen, "LDKCVec_C2Tuple_usizeTransactionZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneChannelMonitorUpdateErrZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NoneChannelMonitorUpdateErrZ*)arg)->result_ok;
-}
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneChannelMonitorUpdateErrZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NoneChannelMonitorUpdateErrZ *val = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t htlc_event_ref = 0;
CHECK((((uint64_t)htlc_event_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&htlc_event_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_event_var);
htlc_event_ref = (uint64_t)htlc_event_var.inner & ~1;
return (*env)->NewObject(env, LDKMonitorEvent_HTLCEvent_class, LDKMonitorEvent_HTLCEvent_meth, htlc_event_ref);
}
uint64_t commitment_tx_confirmed_ref = 0;
CHECK((((uint64_t)commitment_tx_confirmed_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&commitment_tx_confirmed_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_confirmed_var);
commitment_tx_confirmed_ref = (uint64_t)commitment_tx_confirmed_var.inner & ~1;
return (*env)->NewObject(env, LDKMonitorEvent_CommitmentTxConfirmed_class, LDKMonitorEvent_CommitmentTxConfirmed_meth, commitment_tx_confirmed_ref);
}
uint64_t funding_txo_ref = 0;
CHECK((((uint64_t)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
funding_txo_ref = (uint64_t)funding_txo_var.inner & ~1;
return (*env)->NewObject(env, LDKMonitorEvent_UpdateCompleted_class, LDKMonitorEvent_UpdateCompleted_meth, funding_txo_ref, obj->update_completed.monitor_update_id);
}
uint64_t update_failed_ref = 0;
CHECK((((uint64_t)update_failed_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_failed_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_failed_var);
update_failed_ref = (uint64_t)update_failed_var.inner & ~1;
return (*env)->NewObject(env, LDKMonitorEvent_UpdateFailed_class, LDKMonitorEvent_UpdateFailed_meth, update_failed_ref);
}
default: abort();
}
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1MonitorEventZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_MonitorEventZ *ret = MALLOC(sizeof(LDKCVec_MonitorEventZ), "LDKCVec_MonitorEventZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKMonitorEvent) * ret->datalen, "LDKCVec_MonitorEventZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKMonitorEvent arr_elem_conv = *(LDKMonitorEvent*)(arr_elem_ptr);
- arr_elem_conv = MonitorEvent_clone((LDKMonitorEvent*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_MonitorEventZ CVec_MonitorEventZ_clone(const LDKCVec_MonitorEventZ *orig) {
LDKCVec_MonitorEventZ ret = { .data = MALLOC(sizeof(LDKMonitorEvent) * orig->datalen, "LDKCVec_MonitorEventZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
default: abort();
}
}
+static jclass LDKClosureReason_CounterpartyForceClosed_class = NULL;
+static jmethodID LDKClosureReason_CounterpartyForceClosed_meth = NULL;
+static jclass LDKClosureReason_HolderForceClosed_class = NULL;
+static jmethodID LDKClosureReason_HolderForceClosed_meth = NULL;
+static jclass LDKClosureReason_CooperativeClosure_class = NULL;
+static jmethodID LDKClosureReason_CooperativeClosure_meth = NULL;
+static jclass LDKClosureReason_CommitmentTxConfirmed_class = NULL;
+static jmethodID LDKClosureReason_CommitmentTxConfirmed_meth = NULL;
+static jclass LDKClosureReason_ProcessingError_class = NULL;
+static jmethodID LDKClosureReason_ProcessingError_meth = NULL;
+static jclass LDKClosureReason_DisconnectedPeer_class = NULL;
+static jmethodID LDKClosureReason_DisconnectedPeer_meth = NULL;
+static jclass LDKClosureReason_OutdatedChannelManager_class = NULL;
+static jmethodID LDKClosureReason_OutdatedChannelManager_meth = NULL;
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKClosureReason_init (JNIEnv *env, jclass clz) {
+ LDKClosureReason_CounterpartyForceClosed_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$CounterpartyForceClosed;"));
+ CHECK(LDKClosureReason_CounterpartyForceClosed_class != NULL);
+ LDKClosureReason_CounterpartyForceClosed_meth = (*env)->GetMethodID(env, LDKClosureReason_CounterpartyForceClosed_class, "<init>", "(Ljava/lang/String;)V");
+ CHECK(LDKClosureReason_CounterpartyForceClosed_meth != NULL);
+ LDKClosureReason_HolderForceClosed_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$HolderForceClosed;"));
+ CHECK(LDKClosureReason_HolderForceClosed_class != NULL);
+ LDKClosureReason_HolderForceClosed_meth = (*env)->GetMethodID(env, LDKClosureReason_HolderForceClosed_class, "<init>", "()V");
+ CHECK(LDKClosureReason_HolderForceClosed_meth != NULL);
+ LDKClosureReason_CooperativeClosure_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$CooperativeClosure;"));
+ CHECK(LDKClosureReason_CooperativeClosure_class != NULL);
+ LDKClosureReason_CooperativeClosure_meth = (*env)->GetMethodID(env, LDKClosureReason_CooperativeClosure_class, "<init>", "()V");
+ CHECK(LDKClosureReason_CooperativeClosure_meth != NULL);
+ LDKClosureReason_CommitmentTxConfirmed_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$CommitmentTxConfirmed;"));
+ CHECK(LDKClosureReason_CommitmentTxConfirmed_class != NULL);
+ LDKClosureReason_CommitmentTxConfirmed_meth = (*env)->GetMethodID(env, LDKClosureReason_CommitmentTxConfirmed_class, "<init>", "()V");
+ CHECK(LDKClosureReason_CommitmentTxConfirmed_meth != NULL);
+ LDKClosureReason_ProcessingError_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$ProcessingError;"));
+ CHECK(LDKClosureReason_ProcessingError_class != NULL);
+ LDKClosureReason_ProcessingError_meth = (*env)->GetMethodID(env, LDKClosureReason_ProcessingError_class, "<init>", "(Ljava/lang/String;)V");
+ CHECK(LDKClosureReason_ProcessingError_meth != NULL);
+ LDKClosureReason_DisconnectedPeer_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$DisconnectedPeer;"));
+ CHECK(LDKClosureReason_DisconnectedPeer_class != NULL);
+ LDKClosureReason_DisconnectedPeer_meth = (*env)->GetMethodID(env, LDKClosureReason_DisconnectedPeer_class, "<init>", "()V");
+ CHECK(LDKClosureReason_DisconnectedPeer_meth != NULL);
+ LDKClosureReason_OutdatedChannelManager_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$OutdatedChannelManager;"));
+ CHECK(LDKClosureReason_OutdatedChannelManager_class != NULL);
+ LDKClosureReason_OutdatedChannelManager_meth = (*env)->GetMethodID(env, LDKClosureReason_OutdatedChannelManager_class, "<init>", "()V");
+ CHECK(LDKClosureReason_OutdatedChannelManager_meth != NULL);
+}
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKClosureReason_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
+ LDKClosureReason *obj = (LDKClosureReason*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKClosureReason_CounterpartyForceClosed: {
+ LDKStr peer_msg_str = obj->counterparty_force_closed.peer_msg;
+ jstring peer_msg_conv = str_ref_to_java(env, peer_msg_str.chars, peer_msg_str.len);
+ return (*env)->NewObject(env, LDKClosureReason_CounterpartyForceClosed_class, LDKClosureReason_CounterpartyForceClosed_meth, peer_msg_conv);
+ }
+ case LDKClosureReason_HolderForceClosed: {
+ return (*env)->NewObject(env, LDKClosureReason_HolderForceClosed_class, LDKClosureReason_HolderForceClosed_meth);
+ }
+ case LDKClosureReason_CooperativeClosure: {
+ return (*env)->NewObject(env, LDKClosureReason_CooperativeClosure_class, LDKClosureReason_CooperativeClosure_meth);
+ }
+ case LDKClosureReason_CommitmentTxConfirmed: {
+ return (*env)->NewObject(env, LDKClosureReason_CommitmentTxConfirmed_class, LDKClosureReason_CommitmentTxConfirmed_meth);
+ }
+ case LDKClosureReason_ProcessingError: {
+ LDKStr err_str = obj->processing_error.err;
+ jstring err_conv = str_ref_to_java(env, err_str.chars, err_str.len);
+ return (*env)->NewObject(env, LDKClosureReason_ProcessingError_class, LDKClosureReason_ProcessingError_meth, err_conv);
+ }
+ case LDKClosureReason_DisconnectedPeer: {
+ return (*env)->NewObject(env, LDKClosureReason_DisconnectedPeer_class, LDKClosureReason_DisconnectedPeer_meth);
+ }
+ case LDKClosureReason_OutdatedChannelManager: {
+ return (*env)->NewObject(env, LDKClosureReason_OutdatedChannelManager_class, LDKClosureReason_OutdatedChannelManager_meth);
+ }
+ default: abort();
+ }
+}
+static jclass LDKCOption_ClosureReasonZ_Some_class = NULL;
+static jmethodID LDKCOption_ClosureReasonZ_Some_meth = NULL;
+static jclass LDKCOption_ClosureReasonZ_None_class = NULL;
+static jmethodID LDKCOption_ClosureReasonZ_None_meth = NULL;
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKCOption_1ClosureReasonZ_init (JNIEnv *env, jclass clz) {
+ LDKCOption_ClosureReasonZ_Some_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKCOption_ClosureReasonZ$Some;"));
+ CHECK(LDKCOption_ClosureReasonZ_Some_class != NULL);
+ LDKCOption_ClosureReasonZ_Some_meth = (*env)->GetMethodID(env, LDKCOption_ClosureReasonZ_Some_class, "<init>", "(J)V");
+ CHECK(LDKCOption_ClosureReasonZ_Some_meth != NULL);
+ LDKCOption_ClosureReasonZ_None_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKCOption_ClosureReasonZ$None;"));
+ CHECK(LDKCOption_ClosureReasonZ_None_class != NULL);
+ LDKCOption_ClosureReasonZ_None_meth = (*env)->GetMethodID(env, LDKCOption_ClosureReasonZ_None_class, "<init>", "()V");
+ CHECK(LDKCOption_ClosureReasonZ_None_meth != NULL);
+}
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1ClosureReasonZ_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
+ LDKCOption_ClosureReasonZ *obj = (LDKCOption_ClosureReasonZ*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKCOption_ClosureReasonZ_Some: {
+ uint64_t some_ref = ((uint64_t)&obj->some) | 1;
+ return (*env)->NewObject(env, LDKCOption_ClosureReasonZ_Some_class, LDKCOption_ClosureReasonZ_Some_meth, some_ref);
+ }
+ case LDKCOption_ClosureReasonZ_None: {
+ return (*env)->NewObject(env, LDKCOption_ClosureReasonZ_None_class, LDKCOption_ClosureReasonZ_None_meth);
+ }
+ default: abort();
+ }
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1ClosureReasonZDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ *val = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(arg & ~1);
+ CHECK(val->result_ok);
+ uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
+ return res_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1ClosureReasonZDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ *val = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(arg & ~1);
+ CHECK(!val->result_ok);
+ LDKDecodeError err_var = (*val->contents.err);
+ uint64_t err_ref = 0;
+ CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
+ err_ref = (uint64_t)err_var.inner & ~1;
+ return err_ref;
+}
static jclass LDKNetworkUpdate_ChannelUpdateMessage_class = NULL;
static jmethodID LDKNetworkUpdate_ChannelUpdateMessage_meth = NULL;
static jclass LDKNetworkUpdate_ChannelClosed_class = NULL;
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKNetworkUpdate_ChannelUpdateMessage_class, LDKNetworkUpdate_ChannelUpdateMessage_meth, msg_ref);
}
uint64_t outpoint_ref = 0;
CHECK((((uint64_t)outpoint_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&outpoint_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_var);
outpoint_ref = (uint64_t)outpoint_var.inner & ~1;
uint64_t output_ref = ((uint64_t)&obj->static_output.output) | 1;
return (*env)->NewObject(env, LDKSpendableOutputDescriptor_StaticOutput_class, LDKSpendableOutputDescriptor_StaticOutput_meth, outpoint_ref, (uint64_t)output_ref);
uint64_t delayed_payment_output_ref = 0;
CHECK((((uint64_t)delayed_payment_output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&delayed_payment_output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(delayed_payment_output_var);
delayed_payment_output_ref = (uint64_t)delayed_payment_output_var.inner & ~1;
return (*env)->NewObject(env, LDKSpendableOutputDescriptor_DelayedPaymentOutput_class, LDKSpendableOutputDescriptor_DelayedPaymentOutput_meth, delayed_payment_output_ref);
}
uint64_t static_payment_output_ref = 0;
CHECK((((uint64_t)static_payment_output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&static_payment_output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(static_payment_output_var);
static_payment_output_ref = (uint64_t)static_payment_output_var.inner & ~1;
return (*env)->NewObject(env, LDKSpendableOutputDescriptor_StaticPaymentOutput_class, LDKSpendableOutputDescriptor_StaticPaymentOutput_meth, static_payment_output_ref);
}
default: abort();
}
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1SpendableOutputDescriptorZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_SpendableOutputDescriptorZ *ret = MALLOC(sizeof(LDKCVec_SpendableOutputDescriptorZ), "LDKCVec_SpendableOutputDescriptorZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKSpendableOutputDescriptor) * ret->datalen, "LDKCVec_SpendableOutputDescriptorZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKSpendableOutputDescriptor arr_elem_conv = *(LDKSpendableOutputDescriptor*)(arr_elem_ptr);
- arr_elem_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_SpendableOutputDescriptorZ CVec_SpendableOutputDescriptorZ_clone(const LDKCVec_SpendableOutputDescriptorZ *orig) {
LDKCVec_SpendableOutputDescriptorZ ret = { .data = MALLOC(sizeof(LDKSpendableOutputDescriptor) * orig->datalen, "LDKCVec_SpendableOutputDescriptorZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
+static jclass LDKPaymentPurpose_InvoicePayment_class = NULL;
+static jmethodID LDKPaymentPurpose_InvoicePayment_meth = NULL;
+static jclass LDKPaymentPurpose_SpontaneousPayment_class = NULL;
+static jmethodID LDKPaymentPurpose_SpontaneousPayment_meth = NULL;
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKPaymentPurpose_init (JNIEnv *env, jclass clz) {
+ LDKPaymentPurpose_InvoicePayment_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKPaymentPurpose$InvoicePayment;"));
+ CHECK(LDKPaymentPurpose_InvoicePayment_class != NULL);
+ LDKPaymentPurpose_InvoicePayment_meth = (*env)->GetMethodID(env, LDKPaymentPurpose_InvoicePayment_class, "<init>", "([B[BJ)V");
+ CHECK(LDKPaymentPurpose_InvoicePayment_meth != NULL);
+ LDKPaymentPurpose_SpontaneousPayment_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKPaymentPurpose$SpontaneousPayment;"));
+ CHECK(LDKPaymentPurpose_SpontaneousPayment_class != NULL);
+ LDKPaymentPurpose_SpontaneousPayment_meth = (*env)->GetMethodID(env, LDKPaymentPurpose_SpontaneousPayment_class, "<init>", "([B)V");
+ CHECK(LDKPaymentPurpose_SpontaneousPayment_meth != NULL);
+}
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKPaymentPurpose_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
+ LDKPaymentPurpose *obj = (LDKPaymentPurpose*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKPaymentPurpose_InvoicePayment: {
+ int8_tArray payment_preimage_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, payment_preimage_arr, 0, 32, obj->invoice_payment.payment_preimage.data);
+ int8_tArray payment_secret_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, payment_secret_arr, 0, 32, obj->invoice_payment.payment_secret.data);
+ return (*env)->NewObject(env, LDKPaymentPurpose_InvoicePayment_class, LDKPaymentPurpose_InvoicePayment_meth, payment_preimage_arr, payment_secret_arr, obj->invoice_payment.user_payment_id);
+ }
+ case LDKPaymentPurpose_SpontaneousPayment: {
+ int8_tArray spontaneous_payment_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, spontaneous_payment_arr, 0, 32, obj->spontaneous_payment.data);
+ return (*env)->NewObject(env, LDKPaymentPurpose_SpontaneousPayment_class, LDKPaymentPurpose_SpontaneousPayment_meth, spontaneous_payment_arr);
+ }
+ default: abort();
+ }
+}
+static jclass LDKEvent_FundingGenerationReady_class = NULL;
+static jmethodID LDKEvent_FundingGenerationReady_meth = NULL;
+static jclass LDKEvent_PaymentReceived_class = NULL;
+static jmethodID LDKEvent_PaymentReceived_meth = NULL;
+static jclass LDKEvent_PaymentSent_class = NULL;
+static jmethodID LDKEvent_PaymentSent_meth = NULL;
+static jclass LDKEvent_PaymentPathFailed_class = NULL;
+static jmethodID LDKEvent_PaymentPathFailed_meth = NULL;
+static jclass LDKEvent_PendingHTLCsForwardable_class = NULL;
+static jmethodID LDKEvent_PendingHTLCsForwardable_meth = NULL;
+static jclass LDKEvent_SpendableOutputs_class = NULL;
+static jmethodID LDKEvent_SpendableOutputs_meth = NULL;
+static jclass LDKEvent_PaymentForwarded_class = NULL;
+static jmethodID LDKEvent_PaymentForwarded_meth = NULL;
+static jclass LDKEvent_ChannelClosed_class = NULL;
+static jmethodID LDKEvent_ChannelClosed_meth = NULL;
+static jclass LDKEvent_DiscardFunding_class = NULL;
+static jmethodID LDKEvent_DiscardFunding_meth = NULL;
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKEvent_init (JNIEnv *env, jclass clz) {
+ LDKEvent_FundingGenerationReady_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$FundingGenerationReady;"));
+ CHECK(LDKEvent_FundingGenerationReady_class != NULL);
+ LDKEvent_FundingGenerationReady_meth = (*env)->GetMethodID(env, LDKEvent_FundingGenerationReady_class, "<init>", "([BJ[BJ)V");
+ CHECK(LDKEvent_FundingGenerationReady_meth != NULL);
+ LDKEvent_PaymentReceived_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PaymentReceived;"));
+ CHECK(LDKEvent_PaymentReceived_class != NULL);
+ LDKEvent_PaymentReceived_meth = (*env)->GetMethodID(env, LDKEvent_PaymentReceived_class, "<init>", "([BJJ)V");
+ CHECK(LDKEvent_PaymentReceived_meth != NULL);
+ LDKEvent_PaymentSent_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PaymentSent;"));
+ CHECK(LDKEvent_PaymentSent_class != NULL);
+ LDKEvent_PaymentSent_meth = (*env)->GetMethodID(env, LDKEvent_PaymentSent_class, "<init>", "([B[B[BJ)V");
+ CHECK(LDKEvent_PaymentSent_meth != NULL);
+ LDKEvent_PaymentPathFailed_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PaymentPathFailed;"));
+ CHECK(LDKEvent_PaymentPathFailed_class != NULL);
+ LDKEvent_PaymentPathFailed_meth = (*env)->GetMethodID(env, LDKEvent_PaymentPathFailed_class, "<init>", "([B[BZJZ[JJJ)V");
+ CHECK(LDKEvent_PaymentPathFailed_meth != NULL);
+ LDKEvent_PendingHTLCsForwardable_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PendingHTLCsForwardable;"));
+ CHECK(LDKEvent_PendingHTLCsForwardable_class != NULL);
+ LDKEvent_PendingHTLCsForwardable_meth = (*env)->GetMethodID(env, LDKEvent_PendingHTLCsForwardable_class, "<init>", "(J)V");
+ CHECK(LDKEvent_PendingHTLCsForwardable_meth != NULL);
+ LDKEvent_SpendableOutputs_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$SpendableOutputs;"));
+ CHECK(LDKEvent_SpendableOutputs_class != NULL);
+ LDKEvent_SpendableOutputs_meth = (*env)->GetMethodID(env, LDKEvent_SpendableOutputs_class, "<init>", "([J)V");
+ CHECK(LDKEvent_SpendableOutputs_meth != NULL);
+ LDKEvent_PaymentForwarded_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PaymentForwarded;"));
+ CHECK(LDKEvent_PaymentForwarded_class != NULL);
+ LDKEvent_PaymentForwarded_meth = (*env)->GetMethodID(env, LDKEvent_PaymentForwarded_class, "<init>", "(JZ)V");
+ CHECK(LDKEvent_PaymentForwarded_meth != NULL);
+ LDKEvent_ChannelClosed_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$ChannelClosed;"));
+ CHECK(LDKEvent_ChannelClosed_class != NULL);
+ LDKEvent_ChannelClosed_meth = (*env)->GetMethodID(env, LDKEvent_ChannelClosed_class, "<init>", "([BJJ)V");
+ CHECK(LDKEvent_ChannelClosed_meth != NULL);
+ LDKEvent_DiscardFunding_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$DiscardFunding;"));
+ CHECK(LDKEvent_DiscardFunding_class != NULL);
+ LDKEvent_DiscardFunding_meth = (*env)->GetMethodID(env, LDKEvent_DiscardFunding_class, "<init>", "([B[B)V");
+ CHECK(LDKEvent_DiscardFunding_meth != NULL);
+}
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKEvent_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
+ LDKEvent *obj = (LDKEvent*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKEvent_FundingGenerationReady: {
+ int8_tArray temporary_channel_id_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, temporary_channel_id_arr, 0, 32, obj->funding_generation_ready.temporary_channel_id.data);
+ LDKCVec_u8Z output_script_var = obj->funding_generation_ready.output_script;
+ int8_tArray output_script_arr = (*env)->NewByteArray(env, output_script_var.datalen);
+ (*env)->SetByteArrayRegion(env, output_script_arr, 0, output_script_var.datalen, output_script_var.data);
+ return (*env)->NewObject(env, LDKEvent_FundingGenerationReady_class, LDKEvent_FundingGenerationReady_meth, temporary_channel_id_arr, obj->funding_generation_ready.channel_value_satoshis, output_script_arr, obj->funding_generation_ready.user_channel_id);
+ }
+ case LDKEvent_PaymentReceived: {
+ int8_tArray payment_hash_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, payment_hash_arr, 0, 32, obj->payment_received.payment_hash.data);
+ uint64_t purpose_ref = ((uint64_t)&obj->payment_received.purpose) | 1;
+ return (*env)->NewObject(env, LDKEvent_PaymentReceived_class, LDKEvent_PaymentReceived_meth, payment_hash_arr, obj->payment_received.amt, purpose_ref);
+ }
+ case LDKEvent_PaymentSent: {
+ int8_tArray payment_id_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, payment_id_arr, 0, 32, obj->payment_sent.payment_id.data);
+ int8_tArray payment_preimage_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, payment_preimage_arr, 0, 32, obj->payment_sent.payment_preimage.data);
+ int8_tArray payment_hash_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, payment_hash_arr, 0, 32, obj->payment_sent.payment_hash.data);
+ uint64_t fee_paid_msat_ref = ((uint64_t)&obj->payment_sent.fee_paid_msat) | 1;
+ return (*env)->NewObject(env, LDKEvent_PaymentSent_class, LDKEvent_PaymentSent_meth, payment_id_arr, payment_preimage_arr, payment_hash_arr, fee_paid_msat_ref);
+ }
+ case LDKEvent_PaymentPathFailed: {
+ int8_tArray payment_id_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, payment_id_arr, 0, 32, obj->payment_path_failed.payment_id.data);
+ int8_tArray payment_hash_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, payment_hash_arr, 0, 32, obj->payment_path_failed.payment_hash.data);
+ uint64_t network_update_ref = ((uint64_t)&obj->payment_path_failed.network_update) | 1;
+ LDKCVec_RouteHopZ path_var = obj->payment_path_failed.path;
+ int64_tArray path_arr = NULL;
+ path_arr = (*env)->NewLongArray(env, path_var.datalen);
+ int64_t *path_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, path_arr, NULL);
+ for (size_t k = 0; k < path_var.datalen; k++) {
+ LDKRouteHop path_conv_10_var = path_var.data[k];
+ uint64_t path_conv_10_ref = 0;
+ CHECK((((uint64_t)path_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&path_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
+ path_conv_10_ref = (uint64_t)path_conv_10_var.inner & ~1;
+ path_arr_ptr[k] = path_conv_10_ref;
+ }
+ (*env)->ReleasePrimitiveArrayCritical(env, path_arr, path_arr_ptr, 0);
+ uint64_t short_channel_id_ref = ((uint64_t)&obj->payment_path_failed.short_channel_id) | 1;
+ LDKRouteParameters retry_var = obj->payment_path_failed.retry;
+ uint64_t retry_ref = 0;
+ if ((uint64_t)retry_var.inner > 4096) {
+ CHECK((((uint64_t)retry_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&retry_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(retry_var);
+ retry_ref = (uint64_t)retry_var.inner & ~1;
+ }
+ return (*env)->NewObject(env, LDKEvent_PaymentPathFailed_class, LDKEvent_PaymentPathFailed_meth, payment_id_arr, payment_hash_arr, obj->payment_path_failed.rejected_by_dest, network_update_ref, obj->payment_path_failed.all_paths_failed, path_arr, short_channel_id_ref, retry_ref);
+ }
+ case LDKEvent_PendingHTLCsForwardable: {
+ return (*env)->NewObject(env, LDKEvent_PendingHTLCsForwardable_class, LDKEvent_PendingHTLCsForwardable_meth, obj->pending_htl_cs_forwardable.time_forwardable);
+ }
+ case LDKEvent_SpendableOutputs: {
+ LDKCVec_SpendableOutputDescriptorZ outputs_var = obj->spendable_outputs.outputs;
+ int64_tArray outputs_arr = NULL;
+ outputs_arr = (*env)->NewLongArray(env, outputs_var.datalen);
+ int64_t *outputs_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, outputs_arr, NULL);
+ for (size_t b = 0; b < outputs_var.datalen; b++) {
+ uint64_t outputs_conv_27_ref = ((uint64_t)&outputs_var.data[b]) | 1;
+ outputs_arr_ptr[b] = outputs_conv_27_ref;
+ }
+ (*env)->ReleasePrimitiveArrayCritical(env, outputs_arr, outputs_arr_ptr, 0);
+ return (*env)->NewObject(env, LDKEvent_SpendableOutputs_class, LDKEvent_SpendableOutputs_meth, outputs_arr);
+ }
+ case LDKEvent_PaymentForwarded: {
+ uint64_t fee_earned_msat_ref = ((uint64_t)&obj->payment_forwarded.fee_earned_msat) | 1;
+ return (*env)->NewObject(env, LDKEvent_PaymentForwarded_class, LDKEvent_PaymentForwarded_meth, fee_earned_msat_ref, obj->payment_forwarded.claim_from_onchain_tx);
+ }
+ case LDKEvent_ChannelClosed: {
+ int8_tArray channel_id_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, channel_id_arr, 0, 32, obj->channel_closed.channel_id.data);
+ uint64_t reason_ref = ((uint64_t)&obj->channel_closed.reason) | 1;
+ return (*env)->NewObject(env, LDKEvent_ChannelClosed_class, LDKEvent_ChannelClosed_meth, channel_id_arr, obj->channel_closed.user_channel_id, reason_ref);
+ }
+ case LDKEvent_DiscardFunding: {
+ int8_tArray channel_id_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, channel_id_arr, 0, 32, obj->discard_funding.channel_id.data);
+ LDKTransaction transaction_var = obj->discard_funding.transaction;
+ int8_tArray transaction_arr = (*env)->NewByteArray(env, transaction_var.datalen);
+ (*env)->SetByteArrayRegion(env, transaction_arr, 0, transaction_var.datalen, transaction_var.data);
+ return (*env)->NewObject(env, LDKEvent_DiscardFunding_class, LDKEvent_DiscardFunding_meth, channel_id_arr, transaction_arr);
+ }
+ default: abort();
+ }
+}
+static jclass LDKCOption_EventZ_Some_class = NULL;
+static jmethodID LDKCOption_EventZ_Some_meth = NULL;
+static jclass LDKCOption_EventZ_None_class = NULL;
+static jmethodID LDKCOption_EventZ_None_meth = NULL;
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKCOption_1EventZ_init (JNIEnv *env, jclass clz) {
+ LDKCOption_EventZ_Some_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKCOption_EventZ$Some;"));
+ CHECK(LDKCOption_EventZ_Some_class != NULL);
+ LDKCOption_EventZ_Some_meth = (*env)->GetMethodID(env, LDKCOption_EventZ_Some_class, "<init>", "(J)V");
+ CHECK(LDKCOption_EventZ_Some_meth != NULL);
+ LDKCOption_EventZ_None_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKCOption_EventZ$None;"));
+ CHECK(LDKCOption_EventZ_None_class != NULL);
+ LDKCOption_EventZ_None_meth = (*env)->GetMethodID(env, LDKCOption_EventZ_None_class, "<init>", "()V");
+ CHECK(LDKCOption_EventZ_None_meth != NULL);
+}
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1EventZ_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
+ LDKCOption_EventZ *obj = (LDKCOption_EventZ*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKCOption_EventZ_Some: {
+ uint64_t some_ref = ((uint64_t)&obj->some) | 1;
+ return (*env)->NewObject(env, LDKCOption_EventZ_Some_class, LDKCOption_EventZ_Some_meth, some_ref);
+ }
+ case LDKCOption_EventZ_None: {
+ return (*env)->NewObject(env, LDKCOption_EventZ_None_class, LDKCOption_EventZ_None_meth);
+ }
+ default: abort();
+ }
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1EventZDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_EventZDecodeErrorZ *val = (LDKCResult_COption_EventZDecodeErrorZ*)(arg & ~1);
+ CHECK(val->result_ok);
+ uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
+ return res_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1EventZDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_EventZDecodeErrorZ *val = (LDKCResult_COption_EventZDecodeErrorZ*)(arg & ~1);
+ CHECK(!val->result_ok);
+ LDKDecodeError err_var = (*val->contents.err);
+ uint64_t err_ref = 0;
+ CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
+ err_ref = (uint64_t)err_var.inner & ~1;
+ return err_ref;
+}
static jclass LDKErrorAction_DisconnectPeer_class = NULL;
static jmethodID LDKErrorAction_DisconnectPeer_meth = NULL;
static jclass LDKErrorAction_IgnoreError_class = NULL;
if ((uint64_t)msg_var.inner > 4096) {
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
}
return (*env)->NewObject(env, LDKErrorAction_DisconnectPeer_class, LDKErrorAction_DisconnectPeer_meth, msg_ref);
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKErrorAction_SendErrorMessage_class, LDKErrorAction_SendErrorMessage_meth, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendAcceptChannel_class, LDKMessageSendEvent_SendAcceptChannel_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendOpenChannel_class, LDKMessageSendEvent_SendOpenChannel_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendFundingCreated_class, LDKMessageSendEvent_SendFundingCreated_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendFundingSigned_class, LDKMessageSendEvent_SendFundingSigned_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendFundingLocked_class, LDKMessageSendEvent_SendFundingLocked_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendAnnouncementSignatures_class, LDKMessageSendEvent_SendAnnouncementSignatures_meth, node_id_arr, msg_ref);
}
uint64_t updates_ref = 0;
CHECK((((uint64_t)updates_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&updates_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_var);
updates_ref = (uint64_t)updates_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_UpdateHTLCs_class, LDKMessageSendEvent_UpdateHTLCs_meth, node_id_arr, updates_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendRevokeAndACK_class, LDKMessageSendEvent_SendRevokeAndACK_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendClosingSigned_class, LDKMessageSendEvent_SendClosingSigned_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendShutdown_class, LDKMessageSendEvent_SendShutdown_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendChannelReestablish_class, LDKMessageSendEvent_SendChannelReestablish_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
LDKChannelUpdate update_msg_var = obj->broadcast_channel_announcement.update_msg;
uint64_t update_msg_ref = 0;
CHECK((((uint64_t)update_msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_var);
update_msg_ref = (uint64_t)update_msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_BroadcastChannelAnnouncement_class, LDKMessageSendEvent_BroadcastChannelAnnouncement_meth, msg_ref, update_msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_BroadcastNodeAnnouncement_class, LDKMessageSendEvent_BroadcastNodeAnnouncement_meth, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_BroadcastChannelUpdate_class, LDKMessageSendEvent_BroadcastChannelUpdate_meth, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendChannelUpdate_class, LDKMessageSendEvent_SendChannelUpdate_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendChannelRangeQuery_class, LDKMessageSendEvent_SendChannelRangeQuery_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendShortIdsQuery_class, LDKMessageSendEvent_SendShortIdsQuery_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendReplyChannelRange_class, LDKMessageSendEvent_SendReplyChannelRange_meth, node_id_arr, msg_ref);
}
default: abort();
}
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1MessageSendEventZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_MessageSendEventZ *ret = MALLOC(sizeof(LDKCVec_MessageSendEventZ), "LDKCVec_MessageSendEventZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKMessageSendEvent) * ret->datalen, "LDKCVec_MessageSendEventZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKMessageSendEvent arr_elem_conv = *(LDKMessageSendEvent*)(arr_elem_ptr);
- arr_elem_conv = MessageSendEvent_clone((LDKMessageSendEvent*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_MessageSendEventZ CVec_MessageSendEventZ_clone(const LDKCVec_MessageSendEventZ *orig) {
LDKCVec_MessageSendEventZ ret = { .data = MALLOC(sizeof(LDKMessageSendEvent) * orig->datalen, "LDKCVec_MessageSendEventZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_InitFeaturesDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_InitFeaturesDecodeErrorZ *val = (LDKCResult_InitFeaturesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NodeFeaturesDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NodeFeaturesDecodeErrorZ *val = (LDKCResult_NodeFeaturesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ChannelFeaturesDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ChannelFeaturesDecodeErrorZ *val = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceFeaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_InvoiceFeaturesDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceFeaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_InvoiceFeaturesDecodeErrorZ *val = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ScoringParametersDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ScoringParametersDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ScoringParametersDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ScoringParametersDecodeErrorZ *val = (LDKCResult_ScoringParametersDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ScorerDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ScorerDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ScorerDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ScorerDecodeErrorZ *val = (LDKCResult_ScorerDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *val = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *val = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SpendableOutputDescriptorDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SpendableOutputDescriptorDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_SpendableOutputDescriptorDecodeErrorZ *val = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NoneNoneZ*)arg)->result_ok;
-}
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NoneNoneZ *val = (LDKCResult_NoneNoneZ*)(arg & ~1);
CHECK(val->result_ok);
return ret_arr;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *val = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(arg & ~1);
CHECK(val->result_ok);
CHECK(!val->result_ok);
return *val->contents.err;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignatureNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_SignatureNoneZ*)arg)->result_ok;
-}
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignatureNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_SignatureNoneZ *val = (LDKCResult_SignatureNoneZ*)(arg & ~1);
CHECK(val->result_ok);
holder_tx_var = HolderCommitmentTransaction_clone(holder_tx);
CHECK((((uint64_t)holder_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&holder_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_tx_var);
holder_tx_ref = (uint64_t)holder_tx_var.inner;
if (holder_tx_var.is_owned) {
holder_tx_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
- ret_conv = CResult_NoneNoneZ_clone((LDKCResult_NoneNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
commitment_tx_var = CommitmentTransaction_clone(commitment_tx);
CHECK((((uint64_t)commitment_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&commitment_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_var);
commitment_tx_ref = (uint64_t)commitment_tx_var.inner;
if (commitment_tx_var.is_owned) {
commitment_tx_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(ret_ptr);
- ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
- ret_conv = CResult_NoneNoneZ_clone((LDKCResult_NoneNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
commitment_tx_var = HolderCommitmentTransaction_clone(commitment_tx);
CHECK((((uint64_t)commitment_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&commitment_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_var);
commitment_tx_ref = (uint64_t)commitment_tx_var.inner;
if (commitment_tx_var.is_owned) {
commitment_tx_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(ret_ptr);
- ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
htlc_var = HTLCOutputInCommitment_clone(htlc);
CHECK((((uint64_t)htlc_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&htlc_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_var);
htlc_ref = (uint64_t)htlc_var.inner;
if (htlc_var.is_owned) {
htlc_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
htlc_var = HTLCOutputInCommitment_clone(htlc);
CHECK((((uint64_t)htlc_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&htlc_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_var);
htlc_ref = (uint64_t)htlc_var.inner;
if (htlc_var.is_owned) {
htlc_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
closing_tx_var = ClosingTransaction_clone(closing_tx);
CHECK((((uint64_t)closing_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&closing_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(closing_tx_var);
closing_tx_ref = (uint64_t)closing_tx_var.inner;
if (closing_tx_var.is_owned) {
closing_tx_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
msg_var = UnsignedChannelAnnouncement_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
channel_parameters_var = ChannelTransactionParameters_clone(channel_parameters);
CHECK((((uint64_t)channel_parameters_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&channel_parameters_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_var);
channel_parameters_ref = (uint64_t)channel_parameters_var.inner;
if (channel_parameters_var.is_owned) {
channel_parameters_ref |= 1;
LDKChannelPublicKeys pubkeys_conv;
pubkeys_conv.inner = (void*)(pubkeys & (~1));
pubkeys_conv.is_owned = (pubkeys & 1) || (pubkeys == 0);
- pubkeys_conv = ChannelPublicKeys_clone(&pubkeys_conv);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_conv);
LDKBaseSign ret = {
.this_arg = (void*) calls,
LDKHolderCommitmentTransaction holder_tx_conv;
holder_tx_conv.inner = (void*)(holder_tx & (~1));
holder_tx_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_tx_conv);
LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
*ret_conv = (this_arg_conv->validate_holder_commitment)(this_arg_conv->this_arg, &holder_tx_conv);
return (uint64_t)ret_conv;
LDKCommitmentTransaction commitment_tx_conv;
commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
commitment_tx_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
*ret_conv = (this_arg_conv->sign_counterparty_commitment)(this_arg_conv->this_arg, &commitment_tx_conv);
return (uint64_t)ret_conv;
LDKHolderCommitmentTransaction commitment_tx_conv;
commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
commitment_tx_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
*ret_conv = (this_arg_conv->sign_holder_commitment_and_htlcs)(this_arg_conv->this_arg, &commitment_tx_conv);
return (uint64_t)ret_conv;
LDKHTLCOutputInCommitment htlc_conv;
htlc_conv.inner = (void*)(htlc & (~1));
htlc_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
*ret_conv = (this_arg_conv->sign_justice_revoked_htlc)(this_arg_conv->this_arg, justice_tx_ref, input, amount, per_commitment_key_ref, &htlc_conv);
return (uint64_t)ret_conv;
LDKHTLCOutputInCommitment htlc_conv;
htlc_conv.inner = (void*)(htlc & (~1));
htlc_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
*ret_conv = (this_arg_conv->sign_counterparty_htlc_transaction)(this_arg_conv->this_arg, htlc_tx_ref, input, amount, per_commitment_point_ref, &htlc_conv);
return (uint64_t)ret_conv;
LDKClosingTransaction closing_tx_conv;
closing_tx_conv.inner = (void*)(closing_tx & (~1));
closing_tx_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(closing_tx_conv);
LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
*ret_conv = (this_arg_conv->sign_closing_transaction)(this_arg_conv->this_arg, &closing_tx_conv);
return (uint64_t)ret_conv;
LDKUnsignedChannelAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
*ret_conv = (this_arg_conv->sign_channel_announcement)(this_arg_conv->this_arg, &msg_conv);
return (uint64_t)ret_conv;
LDKChannelTransactionParameters channel_parameters_conv;
channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
channel_parameters_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
(this_arg_conv->ready_channel)(this_arg_conv->this_arg, &channel_parameters_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelPublicKeys pubkeys_conv;
pubkeys_conv.inner = (void*)(pubkeys & (~1));
pubkeys_conv.is_owned = (pubkeys & 1) || (pubkeys == 0);
- pubkeys_conv = ChannelPublicKeys_clone(&pubkeys_conv);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_conv);
LDKSign ret = {
.this_arg = (void*) calls,
return ret_arr;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_SignDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_SignDecodeErrorZ *val = (LDKCResult_SignDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RecoverableSignatureNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_RecoverableSignatureNoneZ*)arg)->result_ok;
-}
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RecoverableSignatureNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_RecoverableSignatureNoneZ *val = (LDKCResult_RecoverableSignatureNoneZ*)(arg & ~1);
CHECK(val->result_ok);
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1CVec_1u8ZZNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_CVec_CVec_u8ZZNoneZ*)arg)->result_ok;
-}
JNIEXPORT jobjectArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1CVec_1u8ZZNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_CVec_CVec_u8ZZNoneZ *val = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(arg & ~1);
CHECK(val->result_ok);
CHECK(!val->result_ok);
return *val->contents.err;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InMemorySignerDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_InMemorySignerDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InMemorySignerDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_InMemorySignerDecodeErrorZ *val = (LDKCResult_InMemorySignerDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1TxOutZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_TxOutZ *ret = MALLOC(sizeof(LDKCVec_TxOutZ), "LDKCVec_TxOutZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKTxOut) * ret->datalen, "LDKCVec_TxOutZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKTxOut arr_elem_conv = *(LDKTxOut*)(arr_elem_ptr);
- arr_elem_conv = TxOut_clone((LDKTxOut*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_TxOutZ CVec_TxOutZ_clone(const LDKCVec_TxOutZ *orig) {
LDKCVec_TxOutZ ret = { .data = MALLOC(sizeof(LDKTxOut) * orig->datalen, "LDKCVec_TxOutZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TransactionNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_TransactionNoneZ*)arg)->result_ok;
-}
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TransactionNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_TransactionNoneZ *val = (LDKCResult_TransactionNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1BlockHashChannelMonitorZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_C2Tuple_BlockHashChannelMonitorZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ), "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ) * ret->datalen, "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_BlockHashChannelMonitorZ arr_elem_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_BlockHashChannelMonitorZ_clone((LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_BlockHashChannelMonitorZZ CVec_C2Tuple_BlockHashChannelMonitorZZ_clone(const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ *orig) {
LDKCVec_C2Tuple_BlockHashChannelMonitorZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ) * orig->datalen, "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ *val = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t script_ref = 0;
CHECK((((uint64_t)script_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&script_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(script_var);
script_ref = (uint64_t)script_var.inner & ~1;
return (*env)->NewObject(env, LDKAPIError_IncompatibleShutdownScript_class, LDKAPIError_IncompatibleShutdownScript_meth, script_ref);
}
default: abort();
}
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneAPIErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NoneAPIErrorZ*)arg)->result_ok;
-}
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneAPIErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NoneAPIErrorZ *val = (LDKCResult_NoneAPIErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
return err_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1CResult_1NoneAPIErrorZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_CResult_NoneAPIErrorZZ *ret = MALLOC(sizeof(LDKCVec_CResult_NoneAPIErrorZZ), "LDKCVec_CResult_NoneAPIErrorZZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ) * ret->datalen, "LDKCVec_CResult_NoneAPIErrorZZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKCResult_NoneAPIErrorZ arr_elem_conv = *(LDKCResult_NoneAPIErrorZ*)(arr_elem_ptr);
- arr_elem_conv = CResult_NoneAPIErrorZ_clone((LDKCResult_NoneAPIErrorZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_CResult_NoneAPIErrorZZ CVec_CResult_NoneAPIErrorZZ_clone(const LDKCVec_CResult_NoneAPIErrorZZ *orig) {
LDKCVec_CResult_NoneAPIErrorZZ ret = { .data = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ) * orig->datalen, "LDKCVec_CResult_NoneAPIErrorZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1APIErrorZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_APIErrorZ *ret = MALLOC(sizeof(LDKCVec_APIErrorZ), "LDKCVec_APIErrorZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKAPIError) * ret->datalen, "LDKCVec_APIErrorZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKAPIError arr_elem_conv = *(LDKAPIError*)(arr_elem_ptr);
- arr_elem_conv = APIError_clone((LDKAPIError*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_APIErrorZ CVec_APIErrorZ_clone(const LDKCVec_APIErrorZ *orig) {
LDKCVec_APIErrorZ ret = { .data = MALLOC(sizeof(LDKAPIError) * orig->datalen, "LDKCVec_APIErrorZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1_1u832APIErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult__u832APIErrorZ*)arg)->result_ok;
-}
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1_1u832APIErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult__u832APIErrorZ *val = (LDKCResult__u832APIErrorZ*)(arg & ~1);
CHECK(val->result_ok);
if ((uint64_t)failed_paths_retry_var.inner > 4096) {
CHECK((((uint64_t)failed_paths_retry_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&failed_paths_retry_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(failed_paths_retry_var);
failed_paths_retry_ref = (uint64_t)failed_paths_retry_var.inner & ~1;
}
int8_tArray payment_id_arr = (*env)->NewByteArray(env, 32);
default: abort();
}
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PaymentIdPaymentSendFailureZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_PaymentIdPaymentSendFailureZ*)arg)->result_ok;
-}
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PaymentIdPaymentSendFailureZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_PaymentIdPaymentSendFailureZ *val = (LDKCResult_PaymentIdPaymentSendFailureZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePaymentSendFailureZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NonePaymentSendFailureZ*)arg)->result_ok;
-}
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePaymentSendFailureZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NonePaymentSendFailureZ *val = (LDKCResult_NonePaymentSendFailureZ*)(arg & ~1);
CHECK(val->result_ok);
return ret_arr;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1PaymentHashPaymentIdZPaymentSendFailureZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1PaymentHashPaymentIdZPaymentSendFailureZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *val = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(arg & ~1);
CHECK(val->result_ok);
default: abort();
}
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1NetAddressZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_NetAddressZ *ret = MALLOC(sizeof(LDKCVec_NetAddressZ), "LDKCVec_NetAddressZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKNetAddress) * ret->datalen, "LDKCVec_NetAddressZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKNetAddress arr_elem_conv = *(LDKNetAddress*)(arr_elem_ptr);
- arr_elem_conv = NetAddress_clone((LDKNetAddress*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_NetAddressZ CVec_NetAddressZ_clone(const LDKCVec_NetAddressZ *orig) {
LDKCVec_NetAddressZ ret = { .data = MALLOC(sizeof(LDKNetAddress) * orig->datalen, "LDKCVec_NetAddressZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
return ret_arr;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PaymentSecretAPIErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_PaymentSecretAPIErrorZ*)arg)->result_ok;
-}
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PaymentSecretAPIErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_PaymentSecretAPIErrorZ *val = (LDKCResult_PaymentSecretAPIErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
return err_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1ChannelMonitorZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_ChannelMonitorZ *ret = MALLOC(sizeof(LDKCVec_ChannelMonitorZ), "LDKCVec_ChannelMonitorZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKChannelMonitor) * ret->datalen, "LDKCVec_ChannelMonitorZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKChannelMonitor arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = ChannelMonitor_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_ChannelMonitorZ CVec_ChannelMonitorZ_clone(const LDKCVec_ChannelMonitorZ *orig) {
LDKCVec_ChannelMonitorZ ret = { .data = MALLOC(sizeof(LDKChannelMonitor) * orig->datalen, "LDKCVec_ChannelMonitorZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
uint64_t funding_txo_ref = 0;
CHECK((((uint64_t)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
funding_txo_ref = (uint64_t)funding_txo_var.inner;
if (funding_txo_var.is_owned) {
funding_txo_ref |= 1;
uint64_t monitor_ref = 0;
CHECK((((uint64_t)monitor_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&monitor_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(monitor_var);
monitor_ref = (uint64_t)monitor_var.inner;
if (monitor_var.is_owned) {
monitor_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(ret_ptr);
- ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
uint64_t funding_txo_ref = 0;
CHECK((((uint64_t)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
funding_txo_ref = (uint64_t)funding_txo_var.inner;
if (funding_txo_var.is_owned) {
funding_txo_ref |= 1;
uint64_t update_ref = 0;
CHECK((((uint64_t)update_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_var);
update_ref = (uint64_t)update_var.inner;
if (update_var.is_owned) {
update_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(ret_ptr);
- ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
void* ret_conv_14_ptr = (void*)(((uint64_t)ret_conv_14) & ~1);
CHECK_ACCESS(ret_conv_14_ptr);
LDKMonitorEvent ret_conv_14_conv = *(LDKMonitorEvent*)(ret_conv_14_ptr);
- ret_conv_14_conv = MonitorEvent_clone((LDKMonitorEvent*)(((uint64_t)ret_conv_14) & ~1));
+ FREE((void*)ret_conv_14);
ret_constr.data[o] = ret_conv_14_conv;
}
(*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
LDKOutPoint funding_txo_conv;
funding_txo_conv.inner = (void*)(funding_txo & (~1));
funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
funding_txo_conv = OutPoint_clone(&funding_txo_conv);
LDKChannelMonitor monitor_conv;
monitor_conv.inner = (void*)(monitor & (~1));
monitor_conv.is_owned = (monitor & 1) || (monitor == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(monitor_conv);
monitor_conv = ChannelMonitor_clone(&monitor_conv);
LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
*ret_conv = (this_arg_conv->watch_channel)(this_arg_conv->this_arg, funding_txo_conv, monitor_conv);
LDKOutPoint funding_txo_conv;
funding_txo_conv.inner = (void*)(funding_txo & (~1));
funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
funding_txo_conv = OutPoint_clone(&funding_txo_conv);
LDKChannelMonitorUpdate update_conv;
update_conv.inner = (void*)(update & (~1));
update_conv.is_owned = (update & 1) || (update == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_conv);
update_conv = ChannelMonitorUpdate_clone(&update_conv);
LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
*ret_conv = (this_arg_conv->update_channel)(this_arg_conv->this_arg, funding_txo_conv, update_conv);
LDKShutdownScript ret_conv;
ret_conv.inner = (void*)(ret & (~1));
ret_conv.is_owned = (ret & 1) || (ret == 0);
- ret_conv = ShutdownScript_clone(&ret_conv);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKSign ret_conv = *(LDKSign*)(ret_ptr);
- ret_conv = Sign_clone(&ret_conv);
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignDecodeErrorZ ret_conv = *(LDKCResult_SignDecodeErrorZ*)(ret_ptr);
- ret_conv = CResult_SignDecodeErrorZ_clone((LDKCResult_SignDecodeErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_RecoverableSignatureNoneZ ret_conv = *(LDKCResult_RecoverableSignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_RecoverableSignatureNoneZ_clone((LDKCResult_RecoverableSignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
FREE(j_calls);
}
}
-void log_LDKLogger_jcall(const void* this_arg, const char* record) {
+void log_LDKLogger_jcall(const void* this_arg, const LDKRecord * record) {
LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
JNIEnv *env;
jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
} else {
DO_ASSERT(get_jenv_res == JNI_OK);
}
- const char* record_str = record;
- jstring record_conv = str_ref_to_java(env, record_str, strlen(record_str));
+ LDKRecord record_var = *record;
+ uint64_t record_ref = 0;
+ record_var = Record_clone(record);
+ CHECK((((uint64_t)record_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&record_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(record_var);
+ record_ref = (uint64_t)record_var.inner;
+ if (record_var.is_owned) {
+ record_ref |= 1;
+ }
jobject obj = (*env)->NewLocalRef(env, j_calls->o);
CHECK(obj != NULL);
- (*env)->CallVoidMethod(env, obj, j_calls->log_meth, record_conv);
+ (*env)->CallVoidMethod(env, obj, j_calls->log_meth, record_ref);
if ((*env)->ExceptionCheck(env)) {
(*env)->ExceptionDescribe(env);
(*env)->FatalError(env, "A call to log in LDKLogger from rust threw an exception.");
atomic_init(&calls->refcnt, 1);
DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
calls->o = (*env)->NewWeakGlobalRef(env, o);
- calls->log_meth = (*env)->GetMethodID(env, c, "log", "(Ljava/lang/String;)V");
+ calls->log_meth = (*env)->GetMethodID(env, c, "log", "(J)V");
CHECK(calls->log_meth != NULL);
LDKLogger ret = {
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner & ~1;
return ret_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ChannelConfigDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ChannelConfigDecodeErrorZ *val = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OutPointDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_OutPointDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OutPointDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_OutPointDecodeErrorZ *val = (LDKCResult_OutPointDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
default: abort();
}
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1TypeZDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_COption_TypeZDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1TypeZDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_COption_TypeZDecodeErrorZ *val = (LDKCResult_COption_TypeZDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
uint64_t routing_ref = 0;
CHECK((((uint64_t)routing_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&routing_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(routing_var);
routing_ref = (uint64_t)routing_var.inner & ~1;
return (*env)->NewObject(env, LDKPaymentError_Routing_class, LDKPaymentError_Routing_meth, routing_ref);
}
default: abort();
}
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PaymentIdPaymentErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_PaymentIdPaymentErrorZ*)arg)->result_ok;
-}
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PaymentIdPaymentErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_PaymentIdPaymentErrorZ *val = (LDKCResult_PaymentIdPaymentErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SiPrefixNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_SiPrefixNoneZ*)arg)->result_ok;
-}
JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SiPrefixNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_SiPrefixNoneZ *val = (LDKCResult_SiPrefixNoneZ*)(arg & ~1);
CHECK(val->result_ok);
CHECK(!val->result_ok);
return *val->contents.err;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_InvoiceNoneZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_InvoiceNoneZ *val = (LDKCResult_InvoiceNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
CHECK(!val->result_ok);
return *val->contents.err;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignedRawInvoiceNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_SignedRawInvoiceNoneZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignedRawInvoiceNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_SignedRawInvoiceNoneZ *val = (LDKCResult_SignedRawInvoiceNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PayeePubKeyErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_PayeePubKeyErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PayeePubKeyErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_PayeePubKeyErrorZ *val = (LDKCResult_PayeePubKeyErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
jclass err_conv = LDKSecp256k1Error_to_java(env, (*val->contents.err));
return err_conv;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1PrivateRouteZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_PrivateRouteZ *ret = MALLOC(sizeof(LDKCVec_PrivateRouteZ), "LDKCVec_PrivateRouteZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKPrivateRoute) * ret->datalen, "LDKCVec_PrivateRouteZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKPrivateRoute arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = PrivateRoute_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_PrivateRouteZ CVec_PrivateRouteZ_clone(const LDKCVec_PrivateRouteZ *orig) {
LDKCVec_PrivateRouteZ ret = { .data = MALLOC(sizeof(LDKPrivateRoute) * orig->datalen, "LDKCVec_PrivateRouteZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PositiveTimestampCreationErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_PositiveTimestampCreationErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PositiveTimestampCreationErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_PositiveTimestampCreationErrorZ *val = (LDKCResult_PositiveTimestampCreationErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
jclass err_conv = LDKCreationError_to_java(env, (*val->contents.err));
return err_conv;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneSemanticErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NoneSemanticErrorZ*)arg)->result_ok;
-}
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneSemanticErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NoneSemanticErrorZ *val = (LDKCResult_NoneSemanticErrorZ*)(arg & ~1);
CHECK(val->result_ok);
jclass err_conv = LDKSemanticError_to_java(env, (*val->contents.err));
return err_conv;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceSemanticErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_InvoiceSemanticErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceSemanticErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_InvoiceSemanticErrorZ *val = (LDKCResult_InvoiceSemanticErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
jclass err_conv = LDKSemanticError_to_java(env, (*val->contents.err));
return err_conv;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DescriptionCreationErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_DescriptionCreationErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DescriptionCreationErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_DescriptionCreationErrorZ *val = (LDKCResult_DescriptionCreationErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
jclass err_conv = LDKCreationError_to_java(env, (*val->contents.err));
return err_conv;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ExpiryTimeCreationErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ExpiryTimeCreationErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ExpiryTimeCreationErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ExpiryTimeCreationErrorZ *val = (LDKCResult_ExpiryTimeCreationErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
jclass err_conv = LDKCreationError_to_java(env, (*val->contents.err));
return err_conv;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PrivateRouteCreationErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_PrivateRouteCreationErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PrivateRouteCreationErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_PrivateRouteCreationErrorZ *val = (LDKCResult_PrivateRouteCreationErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
jclass err_conv = LDKCreationError_to_java(env, (*val->contents.err));
return err_conv;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1StringErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_StringErrorZ*)arg)->result_ok;
-}
JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_LDKCResult_1StringErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_StringErrorZ *val = (LDKCResult_StringErrorZ*)(arg & ~1);
CHECK(val->result_ok);
jclass err_conv = LDKSecp256k1Error_to_java(env, (*val->contents.err));
return err_conv;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelMonitorUpdateDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelMonitorUpdateDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ChannelMonitorUpdateDecodeErrorZ *val = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCUpdateDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_HTLCUpdateDecodeErrorZ*)arg)->result_ok;
+static jclass LDKCOption_MonitorEventZ_Some_class = NULL;
+static jmethodID LDKCOption_MonitorEventZ_Some_meth = NULL;
+static jclass LDKCOption_MonitorEventZ_None_class = NULL;
+static jmethodID LDKCOption_MonitorEventZ_None_meth = NULL;
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKCOption_1MonitorEventZ_init (JNIEnv *env, jclass clz) {
+ LDKCOption_MonitorEventZ_Some_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKCOption_MonitorEventZ$Some;"));
+ CHECK(LDKCOption_MonitorEventZ_Some_class != NULL);
+ LDKCOption_MonitorEventZ_Some_meth = (*env)->GetMethodID(env, LDKCOption_MonitorEventZ_Some_class, "<init>", "(J)V");
+ CHECK(LDKCOption_MonitorEventZ_Some_meth != NULL);
+ LDKCOption_MonitorEventZ_None_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKCOption_MonitorEventZ$None;"));
+ CHECK(LDKCOption_MonitorEventZ_None_class != NULL);
+ LDKCOption_MonitorEventZ_None_meth = (*env)->GetMethodID(env, LDKCOption_MonitorEventZ_None_class, "<init>", "()V");
+ CHECK(LDKCOption_MonitorEventZ_None_meth != NULL);
+}
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1MonitorEventZ_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
+ LDKCOption_MonitorEventZ *obj = (LDKCOption_MonitorEventZ*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKCOption_MonitorEventZ_Some: {
+ uint64_t some_ref = ((uint64_t)&obj->some) | 1;
+ return (*env)->NewObject(env, LDKCOption_MonitorEventZ_Some_class, LDKCOption_MonitorEventZ_Some_meth, some_ref);
+ }
+ case LDKCOption_MonitorEventZ_None: {
+ return (*env)->NewObject(env, LDKCOption_MonitorEventZ_None_class, LDKCOption_MonitorEventZ_None_meth);
+ }
+ default: abort();
+ }
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1MonitorEventZDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ *val = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(arg & ~1);
+ CHECK(val->result_ok);
+ uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
+ return res_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1MonitorEventZDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ *val = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(arg & ~1);
+ CHECK(!val->result_ok);
+ LDKDecodeError err_var = (*val->contents.err);
+ uint64_t err_ref = 0;
+ CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
+ err_ref = (uint64_t)err_var.inner & ~1;
+ return err_ref;
}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCUpdateDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_HTLCUpdateDecodeErrorZ *val = (LDKCResult_HTLCUpdateDecodeErrorZ*)(arg & ~1);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneMonitorUpdateErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NoneMonitorUpdateErrorZ*)arg)->result_ok;
-}
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneMonitorUpdateErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NoneMonitorUpdateErrorZ *val = (LDKCResult_NoneMonitorUpdateErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_arr;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1u32ScriptZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_C2Tuple_u32ScriptZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_u32ScriptZZ), "LDKCVec_C2Tuple_u32ScriptZZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ) * ret->datalen, "LDKCVec_C2Tuple_u32ScriptZZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_u32ScriptZ arr_elem_conv = *(LDKC2Tuple_u32ScriptZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_u32ScriptZ_clone((LDKC2Tuple_u32ScriptZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_u32ScriptZZ CVec_C2Tuple_u32ScriptZZ_clone(const LDKCVec_C2Tuple_u32ScriptZZ *orig) {
LDKCVec_C2Tuple_u32ScriptZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ) * orig->datalen, "LDKCVec_C2Tuple_u32ScriptZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
return ret_arr;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ) * ret->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ arr_elem_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone((LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_clone(const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ *orig) {
LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ) * orig->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-static jclass LDKPaymentPurpose_InvoicePayment_class = NULL;
-static jmethodID LDKPaymentPurpose_InvoicePayment_meth = NULL;
-static jclass LDKPaymentPurpose_SpontaneousPayment_class = NULL;
-static jmethodID LDKPaymentPurpose_SpontaneousPayment_meth = NULL;
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKPaymentPurpose_init (JNIEnv *env, jclass clz) {
- LDKPaymentPurpose_InvoicePayment_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKPaymentPurpose$InvoicePayment;"));
- CHECK(LDKPaymentPurpose_InvoicePayment_class != NULL);
- LDKPaymentPurpose_InvoicePayment_meth = (*env)->GetMethodID(env, LDKPaymentPurpose_InvoicePayment_class, "<init>", "([B[BJ)V");
- CHECK(LDKPaymentPurpose_InvoicePayment_meth != NULL);
- LDKPaymentPurpose_SpontaneousPayment_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKPaymentPurpose$SpontaneousPayment;"));
- CHECK(LDKPaymentPurpose_SpontaneousPayment_class != NULL);
- LDKPaymentPurpose_SpontaneousPayment_meth = (*env)->GetMethodID(env, LDKPaymentPurpose_SpontaneousPayment_class, "<init>", "([B)V");
- CHECK(LDKPaymentPurpose_SpontaneousPayment_meth != NULL);
-}
-JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKPaymentPurpose_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
- LDKPaymentPurpose *obj = (LDKPaymentPurpose*)(ptr & ~1);
- switch(obj->tag) {
- case LDKPaymentPurpose_InvoicePayment: {
- int8_tArray payment_preimage_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, payment_preimage_arr, 0, 32, obj->invoice_payment.payment_preimage.data);
- int8_tArray payment_secret_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, payment_secret_arr, 0, 32, obj->invoice_payment.payment_secret.data);
- return (*env)->NewObject(env, LDKPaymentPurpose_InvoicePayment_class, LDKPaymentPurpose_InvoicePayment_meth, payment_preimage_arr, payment_secret_arr, obj->invoice_payment.user_payment_id);
- }
- case LDKPaymentPurpose_SpontaneousPayment: {
- int8_tArray spontaneous_payment_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, spontaneous_payment_arr, 0, 32, obj->spontaneous_payment.data);
- return (*env)->NewObject(env, LDKPaymentPurpose_SpontaneousPayment_class, LDKPaymentPurpose_SpontaneousPayment_meth, spontaneous_payment_arr);
- }
- default: abort();
- }
-}
-static jclass LDKClosureReason_CounterpartyForceClosed_class = NULL;
-static jmethodID LDKClosureReason_CounterpartyForceClosed_meth = NULL;
-static jclass LDKClosureReason_HolderForceClosed_class = NULL;
-static jmethodID LDKClosureReason_HolderForceClosed_meth = NULL;
-static jclass LDKClosureReason_CooperativeClosure_class = NULL;
-static jmethodID LDKClosureReason_CooperativeClosure_meth = NULL;
-static jclass LDKClosureReason_CommitmentTxConfirmed_class = NULL;
-static jmethodID LDKClosureReason_CommitmentTxConfirmed_meth = NULL;
-static jclass LDKClosureReason_ProcessingError_class = NULL;
-static jmethodID LDKClosureReason_ProcessingError_meth = NULL;
-static jclass LDKClosureReason_DisconnectedPeer_class = NULL;
-static jmethodID LDKClosureReason_DisconnectedPeer_meth = NULL;
-static jclass LDKClosureReason_OutdatedChannelManager_class = NULL;
-static jmethodID LDKClosureReason_OutdatedChannelManager_meth = NULL;
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKClosureReason_init (JNIEnv *env, jclass clz) {
- LDKClosureReason_CounterpartyForceClosed_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$CounterpartyForceClosed;"));
- CHECK(LDKClosureReason_CounterpartyForceClosed_class != NULL);
- LDKClosureReason_CounterpartyForceClosed_meth = (*env)->GetMethodID(env, LDKClosureReason_CounterpartyForceClosed_class, "<init>", "(Ljava/lang/String;)V");
- CHECK(LDKClosureReason_CounterpartyForceClosed_meth != NULL);
- LDKClosureReason_HolderForceClosed_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$HolderForceClosed;"));
- CHECK(LDKClosureReason_HolderForceClosed_class != NULL);
- LDKClosureReason_HolderForceClosed_meth = (*env)->GetMethodID(env, LDKClosureReason_HolderForceClosed_class, "<init>", "()V");
- CHECK(LDKClosureReason_HolderForceClosed_meth != NULL);
- LDKClosureReason_CooperativeClosure_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$CooperativeClosure;"));
- CHECK(LDKClosureReason_CooperativeClosure_class != NULL);
- LDKClosureReason_CooperativeClosure_meth = (*env)->GetMethodID(env, LDKClosureReason_CooperativeClosure_class, "<init>", "()V");
- CHECK(LDKClosureReason_CooperativeClosure_meth != NULL);
- LDKClosureReason_CommitmentTxConfirmed_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$CommitmentTxConfirmed;"));
- CHECK(LDKClosureReason_CommitmentTxConfirmed_class != NULL);
- LDKClosureReason_CommitmentTxConfirmed_meth = (*env)->GetMethodID(env, LDKClosureReason_CommitmentTxConfirmed_class, "<init>", "()V");
- CHECK(LDKClosureReason_CommitmentTxConfirmed_meth != NULL);
- LDKClosureReason_ProcessingError_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$ProcessingError;"));
- CHECK(LDKClosureReason_ProcessingError_class != NULL);
- LDKClosureReason_ProcessingError_meth = (*env)->GetMethodID(env, LDKClosureReason_ProcessingError_class, "<init>", "(Ljava/lang/String;)V");
- CHECK(LDKClosureReason_ProcessingError_meth != NULL);
- LDKClosureReason_DisconnectedPeer_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$DisconnectedPeer;"));
- CHECK(LDKClosureReason_DisconnectedPeer_class != NULL);
- LDKClosureReason_DisconnectedPeer_meth = (*env)->GetMethodID(env, LDKClosureReason_DisconnectedPeer_class, "<init>", "()V");
- CHECK(LDKClosureReason_DisconnectedPeer_meth != NULL);
- LDKClosureReason_OutdatedChannelManager_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$OutdatedChannelManager;"));
- CHECK(LDKClosureReason_OutdatedChannelManager_class != NULL);
- LDKClosureReason_OutdatedChannelManager_meth = (*env)->GetMethodID(env, LDKClosureReason_OutdatedChannelManager_class, "<init>", "()V");
- CHECK(LDKClosureReason_OutdatedChannelManager_meth != NULL);
-}
-JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKClosureReason_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
- LDKClosureReason *obj = (LDKClosureReason*)(ptr & ~1);
- switch(obj->tag) {
- case LDKClosureReason_CounterpartyForceClosed: {
- LDKStr peer_msg_str = obj->counterparty_force_closed.peer_msg;
- jstring peer_msg_conv = str_ref_to_java(env, peer_msg_str.chars, peer_msg_str.len);
- return (*env)->NewObject(env, LDKClosureReason_CounterpartyForceClosed_class, LDKClosureReason_CounterpartyForceClosed_meth, peer_msg_conv);
- }
- case LDKClosureReason_HolderForceClosed: {
- return (*env)->NewObject(env, LDKClosureReason_HolderForceClosed_class, LDKClosureReason_HolderForceClosed_meth);
- }
- case LDKClosureReason_CooperativeClosure: {
- return (*env)->NewObject(env, LDKClosureReason_CooperativeClosure_class, LDKClosureReason_CooperativeClosure_meth);
- }
- case LDKClosureReason_CommitmentTxConfirmed: {
- return (*env)->NewObject(env, LDKClosureReason_CommitmentTxConfirmed_class, LDKClosureReason_CommitmentTxConfirmed_meth);
- }
- case LDKClosureReason_ProcessingError: {
- LDKStr err_str = obj->processing_error.err;
- jstring err_conv = str_ref_to_java(env, err_str.chars, err_str.len);
- return (*env)->NewObject(env, LDKClosureReason_ProcessingError_class, LDKClosureReason_ProcessingError_meth, err_conv);
- }
- case LDKClosureReason_DisconnectedPeer: {
- return (*env)->NewObject(env, LDKClosureReason_DisconnectedPeer_class, LDKClosureReason_DisconnectedPeer_meth);
- }
- case LDKClosureReason_OutdatedChannelManager: {
- return (*env)->NewObject(env, LDKClosureReason_OutdatedChannelManager_class, LDKClosureReason_OutdatedChannelManager_meth);
- }
- default: abort();
- }
-}
-static jclass LDKEvent_FundingGenerationReady_class = NULL;
-static jmethodID LDKEvent_FundingGenerationReady_meth = NULL;
-static jclass LDKEvent_PaymentReceived_class = NULL;
-static jmethodID LDKEvent_PaymentReceived_meth = NULL;
-static jclass LDKEvent_PaymentSent_class = NULL;
-static jmethodID LDKEvent_PaymentSent_meth = NULL;
-static jclass LDKEvent_PaymentPathFailed_class = NULL;
-static jmethodID LDKEvent_PaymentPathFailed_meth = NULL;
-static jclass LDKEvent_PendingHTLCsForwardable_class = NULL;
-static jmethodID LDKEvent_PendingHTLCsForwardable_meth = NULL;
-static jclass LDKEvent_SpendableOutputs_class = NULL;
-static jmethodID LDKEvent_SpendableOutputs_meth = NULL;
-static jclass LDKEvent_PaymentForwarded_class = NULL;
-static jmethodID LDKEvent_PaymentForwarded_meth = NULL;
-static jclass LDKEvent_ChannelClosed_class = NULL;
-static jmethodID LDKEvent_ChannelClosed_meth = NULL;
-static jclass LDKEvent_DiscardFunding_class = NULL;
-static jmethodID LDKEvent_DiscardFunding_meth = NULL;
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKEvent_init (JNIEnv *env, jclass clz) {
- LDKEvent_FundingGenerationReady_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$FundingGenerationReady;"));
- CHECK(LDKEvent_FundingGenerationReady_class != NULL);
- LDKEvent_FundingGenerationReady_meth = (*env)->GetMethodID(env, LDKEvent_FundingGenerationReady_class, "<init>", "([BJ[BJ)V");
- CHECK(LDKEvent_FundingGenerationReady_meth != NULL);
- LDKEvent_PaymentReceived_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PaymentReceived;"));
- CHECK(LDKEvent_PaymentReceived_class != NULL);
- LDKEvent_PaymentReceived_meth = (*env)->GetMethodID(env, LDKEvent_PaymentReceived_class, "<init>", "([BJJ)V");
- CHECK(LDKEvent_PaymentReceived_meth != NULL);
- LDKEvent_PaymentSent_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PaymentSent;"));
- CHECK(LDKEvent_PaymentSent_class != NULL);
- LDKEvent_PaymentSent_meth = (*env)->GetMethodID(env, LDKEvent_PaymentSent_class, "<init>", "([B[B[BJ)V");
- CHECK(LDKEvent_PaymentSent_meth != NULL);
- LDKEvent_PaymentPathFailed_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PaymentPathFailed;"));
- CHECK(LDKEvent_PaymentPathFailed_class != NULL);
- LDKEvent_PaymentPathFailed_meth = (*env)->GetMethodID(env, LDKEvent_PaymentPathFailed_class, "<init>", "([B[BZJZ[JJJ)V");
- CHECK(LDKEvent_PaymentPathFailed_meth != NULL);
- LDKEvent_PendingHTLCsForwardable_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PendingHTLCsForwardable;"));
- CHECK(LDKEvent_PendingHTLCsForwardable_class != NULL);
- LDKEvent_PendingHTLCsForwardable_meth = (*env)->GetMethodID(env, LDKEvent_PendingHTLCsForwardable_class, "<init>", "(J)V");
- CHECK(LDKEvent_PendingHTLCsForwardable_meth != NULL);
- LDKEvent_SpendableOutputs_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$SpendableOutputs;"));
- CHECK(LDKEvent_SpendableOutputs_class != NULL);
- LDKEvent_SpendableOutputs_meth = (*env)->GetMethodID(env, LDKEvent_SpendableOutputs_class, "<init>", "([J)V");
- CHECK(LDKEvent_SpendableOutputs_meth != NULL);
- LDKEvent_PaymentForwarded_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PaymentForwarded;"));
- CHECK(LDKEvent_PaymentForwarded_class != NULL);
- LDKEvent_PaymentForwarded_meth = (*env)->GetMethodID(env, LDKEvent_PaymentForwarded_class, "<init>", "(JZ)V");
- CHECK(LDKEvent_PaymentForwarded_meth != NULL);
- LDKEvent_ChannelClosed_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$ChannelClosed;"));
- CHECK(LDKEvent_ChannelClosed_class != NULL);
- LDKEvent_ChannelClosed_meth = (*env)->GetMethodID(env, LDKEvent_ChannelClosed_class, "<init>", "([BJJ)V");
- CHECK(LDKEvent_ChannelClosed_meth != NULL);
- LDKEvent_DiscardFunding_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$DiscardFunding;"));
- CHECK(LDKEvent_DiscardFunding_class != NULL);
- LDKEvent_DiscardFunding_meth = (*env)->GetMethodID(env, LDKEvent_DiscardFunding_class, "<init>", "([B[B)V");
- CHECK(LDKEvent_DiscardFunding_meth != NULL);
-}
-JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKEvent_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
- LDKEvent *obj = (LDKEvent*)(ptr & ~1);
- switch(obj->tag) {
- case LDKEvent_FundingGenerationReady: {
- int8_tArray temporary_channel_id_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, temporary_channel_id_arr, 0, 32, obj->funding_generation_ready.temporary_channel_id.data);
- LDKCVec_u8Z output_script_var = obj->funding_generation_ready.output_script;
- int8_tArray output_script_arr = (*env)->NewByteArray(env, output_script_var.datalen);
- (*env)->SetByteArrayRegion(env, output_script_arr, 0, output_script_var.datalen, output_script_var.data);
- return (*env)->NewObject(env, LDKEvent_FundingGenerationReady_class, LDKEvent_FundingGenerationReady_meth, temporary_channel_id_arr, obj->funding_generation_ready.channel_value_satoshis, output_script_arr, obj->funding_generation_ready.user_channel_id);
- }
- case LDKEvent_PaymentReceived: {
- int8_tArray payment_hash_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, payment_hash_arr, 0, 32, obj->payment_received.payment_hash.data);
- uint64_t purpose_ref = ((uint64_t)&obj->payment_received.purpose) | 1;
- return (*env)->NewObject(env, LDKEvent_PaymentReceived_class, LDKEvent_PaymentReceived_meth, payment_hash_arr, obj->payment_received.amt, purpose_ref);
- }
- case LDKEvent_PaymentSent: {
- int8_tArray payment_id_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, payment_id_arr, 0, 32, obj->payment_sent.payment_id.data);
- int8_tArray payment_preimage_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, payment_preimage_arr, 0, 32, obj->payment_sent.payment_preimage.data);
- int8_tArray payment_hash_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, payment_hash_arr, 0, 32, obj->payment_sent.payment_hash.data);
- uint64_t fee_paid_msat_ref = ((uint64_t)&obj->payment_sent.fee_paid_msat) | 1;
- return (*env)->NewObject(env, LDKEvent_PaymentSent_class, LDKEvent_PaymentSent_meth, payment_id_arr, payment_preimage_arr, payment_hash_arr, fee_paid_msat_ref);
- }
- case LDKEvent_PaymentPathFailed: {
- int8_tArray payment_id_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, payment_id_arr, 0, 32, obj->payment_path_failed.payment_id.data);
- int8_tArray payment_hash_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, payment_hash_arr, 0, 32, obj->payment_path_failed.payment_hash.data);
- uint64_t network_update_ref = ((uint64_t)&obj->payment_path_failed.network_update) | 1;
- LDKCVec_RouteHopZ path_var = obj->payment_path_failed.path;
- int64_tArray path_arr = NULL;
- path_arr = (*env)->NewLongArray(env, path_var.datalen);
- int64_t *path_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, path_arr, NULL);
- for (size_t k = 0; k < path_var.datalen; k++) {
- LDKRouteHop path_conv_10_var = path_var.data[k];
- uint64_t path_conv_10_ref = 0;
- CHECK((((uint64_t)path_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
- CHECK((((uint64_t)&path_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
- path_conv_10_ref = (uint64_t)path_conv_10_var.inner & ~1;
- path_arr_ptr[k] = path_conv_10_ref;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, path_arr, path_arr_ptr, 0);
- uint64_t short_channel_id_ref = ((uint64_t)&obj->payment_path_failed.short_channel_id) | 1;
- LDKRouteParameters retry_var = obj->payment_path_failed.retry;
- uint64_t retry_ref = 0;
- if ((uint64_t)retry_var.inner > 4096) {
- CHECK((((uint64_t)retry_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
- CHECK((((uint64_t)&retry_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
- retry_ref = (uint64_t)retry_var.inner & ~1;
- }
- return (*env)->NewObject(env, LDKEvent_PaymentPathFailed_class, LDKEvent_PaymentPathFailed_meth, payment_id_arr, payment_hash_arr, obj->payment_path_failed.rejected_by_dest, network_update_ref, obj->payment_path_failed.all_paths_failed, path_arr, short_channel_id_ref, retry_ref);
- }
- case LDKEvent_PendingHTLCsForwardable: {
- return (*env)->NewObject(env, LDKEvent_PendingHTLCsForwardable_class, LDKEvent_PendingHTLCsForwardable_meth, obj->pending_htl_cs_forwardable.time_forwardable);
- }
- case LDKEvent_SpendableOutputs: {
- LDKCVec_SpendableOutputDescriptorZ outputs_var = obj->spendable_outputs.outputs;
- int64_tArray outputs_arr = NULL;
- outputs_arr = (*env)->NewLongArray(env, outputs_var.datalen);
- int64_t *outputs_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, outputs_arr, NULL);
- for (size_t b = 0; b < outputs_var.datalen; b++) {
- uint64_t outputs_conv_27_ref = ((uint64_t)&outputs_var.data[b]) | 1;
- outputs_arr_ptr[b] = outputs_conv_27_ref;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, outputs_arr, outputs_arr_ptr, 0);
- return (*env)->NewObject(env, LDKEvent_SpendableOutputs_class, LDKEvent_SpendableOutputs_meth, outputs_arr);
- }
- case LDKEvent_PaymentForwarded: {
- uint64_t fee_earned_msat_ref = ((uint64_t)&obj->payment_forwarded.fee_earned_msat) | 1;
- return (*env)->NewObject(env, LDKEvent_PaymentForwarded_class, LDKEvent_PaymentForwarded_meth, fee_earned_msat_ref, obj->payment_forwarded.claim_from_onchain_tx);
- }
- case LDKEvent_ChannelClosed: {
- int8_tArray channel_id_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, channel_id_arr, 0, 32, obj->channel_closed.channel_id.data);
- uint64_t reason_ref = ((uint64_t)&obj->channel_closed.reason) | 1;
- return (*env)->NewObject(env, LDKEvent_ChannelClosed_class, LDKEvent_ChannelClosed_meth, channel_id_arr, obj->channel_closed.user_channel_id, reason_ref);
- }
- case LDKEvent_DiscardFunding: {
- int8_tArray channel_id_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, channel_id_arr, 0, 32, obj->discard_funding.channel_id.data);
- LDKTransaction transaction_var = obj->discard_funding.transaction;
- int8_tArray transaction_arr = (*env)->NewByteArray(env, transaction_var.datalen);
- (*env)->SetByteArrayRegion(env, transaction_arr, 0, transaction_var.datalen, transaction_var.data);
- return (*env)->NewObject(env, LDKEvent_DiscardFunding_class, LDKEvent_DiscardFunding_meth, channel_id_arr, transaction_arr);
- }
- default: abort();
- }
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1EventZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_EventZ *ret = MALLOC(sizeof(LDKCVec_EventZ), "LDKCVec_EventZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKEvent) * ret->datalen, "LDKCVec_EventZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKEvent arr_elem_conv = *(LDKEvent*)(arr_elem_ptr);
- arr_elem_conv = Event_clone((LDKEvent*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_EventZ CVec_EventZ_clone(const LDKCVec_EventZ *orig) {
LDKCVec_EventZ ret = { .data = MALLOC(sizeof(LDKEvent) * orig->datalen, "LDKCVec_EventZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
return (uint64_t)ret_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1u32TxOutZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_C2Tuple_u32TxOutZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_u32TxOutZZ), "LDKCVec_C2Tuple_u32TxOutZZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ) * ret->datalen, "LDKCVec_C2Tuple_u32TxOutZZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_u32TxOutZ arr_elem_conv = *(LDKC2Tuple_u32TxOutZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_u32TxOutZ_clone((LDKC2Tuple_u32TxOutZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_u32TxOutZZ CVec_C2Tuple_u32TxOutZZ_clone(const LDKCVec_C2Tuple_u32TxOutZZ *orig) {
LDKCVec_C2Tuple_u32TxOutZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ) * orig->datalen, "LDKCVec_C2Tuple_u32TxOutZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
return ret_arr;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ) * ret->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ arr_elem_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone((LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_clone(const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ *orig) {
LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ) * orig->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
default: abort();
}
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1BalanceZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_BalanceZ *ret = MALLOC(sizeof(LDKCVec_BalanceZ), "LDKCVec_BalanceZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKBalance) * ret->datalen, "LDKCVec_BalanceZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKBalance arr_elem_conv = *(LDKBalance*)(arr_elem_ptr);
- arr_elem_conv = Balance_clone((LDKBalance*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_BalanceZ CVec_BalanceZ_clone(const LDKCVec_BalanceZ *orig) {
LDKCVec_BalanceZ ret = { .data = MALLOC(sizeof(LDKBalance) * orig->datalen, "LDKCVec_BalanceZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NoneLightningErrorZ*)arg)->result_ok;
-}
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NoneLightningErrorZ *val = (LDKCResult_NoneLightningErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
return (uint64_t)ret_ret;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1PublicKeyTypeZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_C2Tuple_PublicKeyTypeZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_PublicKeyTypeZZ), "LDKCVec_C2Tuple_PublicKeyTypeZZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ) * ret->datalen, "LDKCVec_C2Tuple_PublicKeyTypeZZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_PublicKeyTypeZ arr_elem_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_PublicKeyTypeZ_clone((LDKC2Tuple_PublicKeyTypeZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_PublicKeyTypeZZ CVec_C2Tuple_PublicKeyTypeZZ_clone(const LDKCVec_C2Tuple_PublicKeyTypeZZ *orig) {
LDKCVec_C2Tuple_PublicKeyTypeZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ) * orig->datalen, "LDKCVec_C2Tuple_PublicKeyTypeZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_boolLightningErrorZ*)arg)->result_ok;
-}
JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_boolLightningErrorZ *val = (LDKCResult_boolLightningErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret = MALLOC(sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) * ret->datalen, "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ arr_elem_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(arr_elem_ptr);
- arr_elem_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone((LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *orig) {
LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret = { .data = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) * orig->datalen, "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1NodeAnnouncementZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_NodeAnnouncementZ *ret = MALLOC(sizeof(LDKCVec_NodeAnnouncementZ), "LDKCVec_NodeAnnouncementZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKNodeAnnouncement) * ret->datalen, "LDKCVec_NodeAnnouncementZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKNodeAnnouncement arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = NodeAnnouncement_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_NodeAnnouncementZ CVec_NodeAnnouncementZ_clone(const LDKCVec_NodeAnnouncementZ *orig) {
LDKCVec_NodeAnnouncementZ ret = { .data = MALLOC(sizeof(LDKNodeAnnouncement) * orig->datalen, "LDKCVec_NodeAnnouncementZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_CVec_u8ZPeerHandleErrorZ*)arg)->result_ok;
-}
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_CVec_u8ZPeerHandleErrorZ *val = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NonePeerHandleErrorZ*)arg)->result_ok;
-}
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NonePeerHandleErrorZ *val = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_boolPeerHandleErrorZ*)arg)->result_ok;
-}
JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_boolPeerHandleErrorZ *val = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeIdDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NodeIdDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeIdDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NodeIdDecodeErrorZ *val = (LDKCResult_NodeIdDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
+ err_ref = (uint64_t)err_var.inner & ~1;
+ return err_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1NetworkUpdateZDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ *val = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(arg & ~1);
+ CHECK(val->result_ok);
+ uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
+ return res_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1NetworkUpdateZDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ *val = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(arg & ~1);
+ CHECK(!val->result_ok);
+ LDKDecodeError err_var = (*val->contents.err);
+ uint64_t err_ref = 0;
+ CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_TxOutAccessErrorZ ret_conv = *(LDKCResult_TxOutAccessErrorZ*)(ret_ptr);
- ret_conv = CResult_TxOutAccessErrorZ_clone((LDKCResult_TxOutAccessErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
default: abort();
}
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DirectionalChannelInfoDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_DirectionalChannelInfoDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DirectionalChannelInfoDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_DirectionalChannelInfoDecodeErrorZ *val = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelInfoDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ChannelInfoDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelInfoDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ChannelInfoDecodeErrorZ *val = (LDKCResult_ChannelInfoDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RoutingFeesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_RoutingFeesDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RoutingFeesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_RoutingFeesDecodeErrorZ *val = (LDKCResult_RoutingFeesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementInfoDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementInfoDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NodeAnnouncementInfoDecodeErrorZ *val = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1u64Z_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_u64Z *ret = MALLOC(sizeof(LDKCVec_u64Z), "LDKCVec_u64Z");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(uint64_t) * ret->datalen, "LDKCVec_u64Z Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- ret->data[i] = java_elems[i];
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_u64Z CVec_u64Z_clone(const LDKCVec_u64Z *orig) {
LDKCVec_u64Z ret = { .data = MALLOC(sizeof(int64_t) * orig->datalen, "LDKCVec_u64Z clone bytes"), .datalen = orig->datalen };
memcpy(ret.data, orig->data, sizeof(int64_t) * ret.datalen);
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeInfoDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NodeInfoDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeInfoDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NodeInfoDecodeErrorZ *val = (LDKCResult_NodeInfoDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetworkGraphDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NetworkGraphDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetworkGraphDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NetworkGraphDecodeErrorZ *val = (LDKCResult_NetworkGraphDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
default: abort();
}
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetAddressDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NetAddressDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetAddressDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NetAddressDecodeErrorZ *val = (LDKCResult_NetAddressDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1UpdateAddHTLCZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_UpdateAddHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateAddHTLCZ), "LDKCVec_UpdateAddHTLCZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKUpdateAddHTLC) * ret->datalen, "LDKCVec_UpdateAddHTLCZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKUpdateAddHTLC arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = UpdateAddHTLC_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_UpdateAddHTLCZ CVec_UpdateAddHTLCZ_clone(const LDKCVec_UpdateAddHTLCZ *orig) {
LDKCVec_UpdateAddHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateAddHTLC) * orig->datalen, "LDKCVec_UpdateAddHTLCZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1UpdateFulfillHTLCZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_UpdateFulfillHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateFulfillHTLCZ), "LDKCVec_UpdateFulfillHTLCZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKUpdateFulfillHTLC) * ret->datalen, "LDKCVec_UpdateFulfillHTLCZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKUpdateFulfillHTLC arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = UpdateFulfillHTLC_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_UpdateFulfillHTLCZ CVec_UpdateFulfillHTLCZ_clone(const LDKCVec_UpdateFulfillHTLCZ *orig) {
LDKCVec_UpdateFulfillHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFulfillHTLC) * orig->datalen, "LDKCVec_UpdateFulfillHTLCZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1UpdateFailHTLCZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_UpdateFailHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateFailHTLCZ), "LDKCVec_UpdateFailHTLCZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKUpdateFailHTLC) * ret->datalen, "LDKCVec_UpdateFailHTLCZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKUpdateFailHTLC arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = UpdateFailHTLC_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_UpdateFailHTLCZ CVec_UpdateFailHTLCZ_clone(const LDKCVec_UpdateFailHTLCZ *orig) {
LDKCVec_UpdateFailHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailHTLC) * orig->datalen, "LDKCVec_UpdateFailHTLCZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1UpdateFailMalformedHTLCZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_UpdateFailMalformedHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateFailMalformedHTLCZ), "LDKCVec_UpdateFailMalformedHTLCZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKUpdateFailMalformedHTLC) * ret->datalen, "LDKCVec_UpdateFailMalformedHTLCZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKUpdateFailMalformedHTLC arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = UpdateFailMalformedHTLC_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_UpdateFailMalformedHTLCZ CVec_UpdateFailMalformedHTLCZ_clone(const LDKCVec_UpdateFailMalformedHTLCZ *orig) {
LDKCVec_UpdateFailMalformedHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailMalformedHTLC) * orig->datalen, "LDKCVec_UpdateFailMalformedHTLCZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AcceptChannelDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_AcceptChannelDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AcceptChannelDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_AcceptChannelDecodeErrorZ *val = (LDKCResult_AcceptChannelDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AnnouncementSignaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_AnnouncementSignaturesDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AnnouncementSignaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_AnnouncementSignaturesDecodeErrorZ *val = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelReestablishDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ChannelReestablishDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelReestablishDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ChannelReestablishDecodeErrorZ *val = (LDKCResult_ChannelReestablishDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ClosingSignedDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ClosingSignedDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ClosingSignedDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ClosingSignedDecodeErrorZ *val = (LDKCResult_ClosingSignedDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ClosingSignedFeeRangeDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ClosingSignedFeeRangeDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *val = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentSignedDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_CommitmentSignedDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentSignedDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_CommitmentSignedDecodeErrorZ *val = (LDKCResult_CommitmentSignedDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingCreatedDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_FundingCreatedDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingCreatedDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_FundingCreatedDecodeErrorZ *val = (LDKCResult_FundingCreatedDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingSignedDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_FundingSignedDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingSignedDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_FundingSignedDecodeErrorZ *val = (LDKCResult_FundingSignedDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingLockedDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_FundingLockedDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingLockedDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_FundingLockedDecodeErrorZ *val = (LDKCResult_FundingLockedDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_InitDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_InitDecodeErrorZ *val = (LDKCResult_InitDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OpenChannelDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_OpenChannelDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OpenChannelDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_OpenChannelDecodeErrorZ *val = (LDKCResult_OpenChannelDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RevokeAndACKDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_RevokeAndACKDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RevokeAndACKDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_RevokeAndACKDecodeErrorZ *val = (LDKCResult_RevokeAndACKDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ShutdownDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ShutdownDecodeErrorZ *val = (LDKCResult_ShutdownDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailHTLCDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_UpdateFailHTLCDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailHTLCDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_UpdateFailHTLCDecodeErrorZ *val = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailMalformedHTLCDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailMalformedHTLCDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *val = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFeeDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_UpdateFeeDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFeeDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_UpdateFeeDecodeErrorZ *val = (LDKCResult_UpdateFeeDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFulfillHTLCDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFulfillHTLCDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_UpdateFulfillHTLCDecodeErrorZ *val = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateAddHTLCDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_UpdateAddHTLCDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateAddHTLCDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_UpdateAddHTLCDecodeErrorZ *val = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PingDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_PingDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PingDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_PingDecodeErrorZ *val = (LDKCResult_PingDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PongDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_PongDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PongDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_PongDecodeErrorZ *val = (LDKCResult_PongDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelAnnouncementDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelAnnouncementDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *val = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelAnnouncementDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ChannelAnnouncementDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelAnnouncementDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ChannelAnnouncementDecodeErrorZ *val = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelUpdateDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelUpdateDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_UnsignedChannelUpdateDecodeErrorZ *val = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelUpdateDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ChannelUpdateDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelUpdateDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ChannelUpdateDecodeErrorZ *val = (LDKCResult_ChannelUpdateDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ErrorMessageDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ErrorMessageDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ErrorMessageDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ErrorMessageDecodeErrorZ *val = (LDKCResult_ErrorMessageDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedNodeAnnouncementDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedNodeAnnouncementDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *val = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NodeAnnouncementDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NodeAnnouncementDecodeErrorZ *val = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryShortChannelIdsDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_QueryShortChannelIdsDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryShortChannelIdsDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_QueryShortChannelIdsDecodeErrorZ *val = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyShortChannelIdsEndDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyShortChannelIdsEndDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *val = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryChannelRangeDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_QueryChannelRangeDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryChannelRangeDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_QueryChannelRangeDecodeErrorZ *val = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyChannelRangeDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ReplyChannelRangeDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyChannelRangeDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ReplyChannelRangeDecodeErrorZ *val = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1GossipTimestampFilterDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_GossipTimestampFilterDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1GossipTimestampFilterDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_GossipTimestampFilterDecodeErrorZ *val = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
default: abort();
}
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceSignOrCreationErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_InvoiceSignOrCreationErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceSignOrCreationErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_InvoiceSignOrCreationErrorZ *val = (LDKCResult_InvoiceSignOrCreationErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t output_ref = 0;
CHECK((((uint64_t)output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(output_var);
output_ref = (uint64_t)output_var.inner;
if (output_var.is_owned) {
output_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCOption_C2Tuple_usizeTransactionZZ ret_conv = *(LDKCOption_C2Tuple_usizeTransactionZZ*)(ret_ptr);
- ret_conv = COption_C2Tuple_usizeTransactionZZ_clone((LDKCOption_C2Tuple_usizeTransactionZZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
LDKWatchedOutput output_conv;
output_conv.inner = (void*)(output & (~1));
output_conv.is_owned = (output & 1) || (output == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(output_conv);
output_conv = WatchedOutput_clone(&output_conv);
LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
*ret_copy = (this_arg_conv->register_output)(this_arg_conv->this_arg, output_conv);
default: abort();
}
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1LockedChannelMonitorNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_LockedChannelMonitorNoneZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1LockedChannelMonitorNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_LockedChannelMonitorNoneZ *val = (LDKCResult_LockedChannelMonitorNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
CHECK(!val->result_ok);
return *val->contents.err;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1OutPointZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_OutPointZ *ret = MALLOC(sizeof(LDKCVec_OutPointZ), "LDKCVec_OutPointZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKOutPoint) * ret->datalen, "LDKCVec_OutPointZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKOutPoint arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = OutPoint_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_OutPointZ CVec_OutPointZ_clone(const LDKCVec_OutPointZ *orig) {
LDKCVec_OutPointZ ret = { .data = MALLOC(sizeof(LDKOutPoint) * orig->datalen, "LDKCVec_OutPointZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
void* ret_conv_18_ptr = (void*)(((uint64_t)ret_conv_18) & ~1);
CHECK_ACCESS(ret_conv_18_ptr);
LDKMessageSendEvent ret_conv_18_conv = *(LDKMessageSendEvent*)(ret_conv_18_ptr);
- ret_conv_18_conv = MessageSendEvent_clone((LDKMessageSendEvent*)(((uint64_t)ret_conv_18) & ~1));
+ FREE((void*)ret_conv_18);
ret_constr.data[s] = ret_conv_18_conv;
}
(*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
uint64_t channel_id_ref = 0;
CHECK((((uint64_t)channel_id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&channel_id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_var);
channel_id_ref = (uint64_t)channel_id_var.inner;
if (channel_id_var.is_owned) {
channel_id_ref |= 1;
data_var = ChannelMonitor_clone(data);
CHECK((((uint64_t)data_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&data_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(data_var);
data_ref = (uint64_t)data_var.inner;
if (data_var.is_owned) {
data_ref |= 1;
uint64_t update_id_ref = 0;
CHECK((((uint64_t)update_id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_var);
update_id_ref = (uint64_t)update_id_var.inner;
if (update_id_var.is_owned) {
update_id_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(ret_ptr);
- ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
uint64_t channel_id_ref = 0;
CHECK((((uint64_t)channel_id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&channel_id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_var);
channel_id_ref = (uint64_t)channel_id_var.inner;
if (channel_id_var.is_owned) {
channel_id_ref |= 1;
update_var = ChannelMonitorUpdate_clone(update);
CHECK((((uint64_t)update_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_var);
update_ref = (uint64_t)update_var.inner;
if (update_var.is_owned) {
update_ref |= 1;
data_var = ChannelMonitor_clone(data);
CHECK((((uint64_t)data_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&data_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(data_var);
data_ref = (uint64_t)data_var.inner;
if (data_var.is_owned) {
data_ref |= 1;
uint64_t update_id_ref = 0;
CHECK((((uint64_t)update_id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_var);
update_id_ref = (uint64_t)update_id_var.inner;
if (update_id_var.is_owned) {
update_id_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(ret_ptr);
- ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
LDKOutPoint channel_id_conv;
channel_id_conv.inner = (void*)(channel_id & (~1));
channel_id_conv.is_owned = (channel_id & 1) || (channel_id == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_conv);
channel_id_conv = OutPoint_clone(&channel_id_conv);
LDKChannelMonitor data_conv;
data_conv.inner = (void*)(data & (~1));
data_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(data_conv);
LDKMonitorUpdateId update_id_conv;
update_id_conv.inner = (void*)(update_id & (~1));
update_id_conv.is_owned = (update_id & 1) || (update_id == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_conv);
update_id_conv = MonitorUpdateId_clone(&update_id_conv);
LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
*ret_conv = (this_arg_conv->persist_new_channel)(this_arg_conv->this_arg, channel_id_conv, &data_conv, update_id_conv);
LDKOutPoint channel_id_conv;
channel_id_conv.inner = (void*)(channel_id & (~1));
channel_id_conv.is_owned = (channel_id & 1) || (channel_id == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_conv);
channel_id_conv = OutPoint_clone(&channel_id_conv);
LDKChannelMonitorUpdate update_conv;
update_conv.inner = (void*)(update & (~1));
update_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_conv);
LDKChannelMonitor data_conv;
data_conv.inner = (void*)(data & (~1));
data_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(data_conv);
LDKMonitorUpdateId update_id_conv;
update_id_conv.inner = (void*)(update_id & (~1));
update_id_conv.is_owned = (update_id & 1) || (update_id == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_conv);
update_id_conv = MonitorUpdateId_clone(&update_id_conv);
LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
*ret_conv = (this_arg_conv->update_persisted_channel)(this_arg_conv->this_arg, channel_id_conv, &update_conv, &data_conv, update_id_conv);
uint64_t their_features_ref = 0;
CHECK((((uint64_t)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_var);
their_features_ref = (uint64_t)their_features_var.inner;
if (their_features_var.is_owned) {
their_features_ref |= 1;
msg_var = OpenChannel_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
uint64_t their_features_ref = 0;
CHECK((((uint64_t)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_var);
their_features_ref = (uint64_t)their_features_var.inner;
if (their_features_var.is_owned) {
their_features_ref |= 1;
msg_var = AcceptChannel_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = FundingCreated_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = FundingSigned_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = FundingLocked_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
their_features_var = InitFeatures_clone(their_features);
CHECK((((uint64_t)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_var);
their_features_ref = (uint64_t)their_features_var.inner;
if (their_features_var.is_owned) {
their_features_ref |= 1;
msg_var = Shutdown_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = ClosingSigned_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = UpdateAddHTLC_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = UpdateFulfillHTLC_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = UpdateFailHTLC_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = UpdateFailMalformedHTLC_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = CommitmentSigned_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = RevokeAndACK_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = UpdateFee_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = AnnouncementSignatures_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = Init_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = ChannelReestablish_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = ChannelUpdate_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = ErrorMessage_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
LDKInitFeatures their_features_conv;
their_features_conv.inner = (void*)(their_features & (~1));
their_features_conv.is_owned = (their_features & 1) || (their_features == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_conv);
their_features_conv = InitFeatures_clone(&their_features_conv);
LDKOpenChannel msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_open_channel)(this_arg_conv->this_arg, their_node_id_ref, their_features_conv, &msg_conv);
}
LDKInitFeatures their_features_conv;
their_features_conv.inner = (void*)(their_features & (~1));
their_features_conv.is_owned = (their_features & 1) || (their_features == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_conv);
their_features_conv = InitFeatures_clone(&their_features_conv);
LDKAcceptChannel msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_accept_channel)(this_arg_conv->this_arg, their_node_id_ref, their_features_conv, &msg_conv);
}
LDKFundingCreated msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_funding_created)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKFundingSigned msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_funding_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKFundingLocked msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_funding_locked)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKInitFeatures their_features_conv;
their_features_conv.inner = (void*)(their_features & (~1));
their_features_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_conv);
LDKShutdown msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_shutdown)(this_arg_conv->this_arg, their_node_id_ref, &their_features_conv, &msg_conv);
}
LDKClosingSigned msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_closing_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKUpdateAddHTLC msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_update_add_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKUpdateFulfillHTLC msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_update_fulfill_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKUpdateFailHTLC msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_update_fail_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKUpdateFailMalformedHTLC msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_update_fail_malformed_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKCommitmentSigned msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_commitment_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKRevokeAndACK msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_revoke_and_ack)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKUpdateFee msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_update_fee)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKAnnouncementSignatures msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_announcement_signatures)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKInit msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->peer_connected)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKChannelReestablish msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_channel_reestablish)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKErrorMessage msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_error)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
msg_var = NodeAnnouncement_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
msg_var = ChannelAnnouncement_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
msg_var = ChannelUpdate_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
void* ret_conv_59_ptr = (void*)(((uint64_t)ret_conv_59) & ~1);
CHECK_ACCESS(ret_conv_59_ptr);
LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ ret_conv_59_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ret_conv_59_ptr);
- ret_conv_59_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone((LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)ret_conv_59) & ~1));
+ FREE((void*)ret_conv_59);
ret_constr.data[h] = ret_conv_59_conv;
}
(*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
LDKNodeAnnouncement ret_conv_18_conv;
ret_conv_18_conv.inner = (void*)(ret_conv_18 & (~1));
ret_conv_18_conv.is_owned = (ret_conv_18 & 1) || (ret_conv_18 == 0);
- ret_conv_18_conv = NodeAnnouncement_clone(&ret_conv_18_conv);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_18_conv);
ret_constr.data[s] = ret_conv_18_conv;
}
(*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
init_var = Init_clone(init);
CHECK((((uint64_t)init_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&init_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(init_var);
init_ref = (uint64_t)init_var.inner;
if (init_var.is_owned) {
init_ref |= 1;
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
LDKNodeAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
*ret_conv = (this_arg_conv->handle_node_announcement)(this_arg_conv->this_arg, &msg_conv);
return (uint64_t)ret_conv;
LDKChannelAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
*ret_conv = (this_arg_conv->handle_channel_announcement)(this_arg_conv->this_arg, &msg_conv);
return (uint64_t)ret_conv;
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
*ret_conv = (this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, &msg_conv);
return (uint64_t)ret_conv;
uint64_t ret_conv_18_ref = 0;
CHECK((((uint64_t)ret_conv_18_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_18_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_18_var);
ret_conv_18_ref = (uint64_t)ret_conv_18_var.inner;
if (ret_conv_18_var.is_owned) {
ret_conv_18_ref |= 1;
LDKInit init_conv;
init_conv.inner = (void*)(init & (~1));
init_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(init_conv);
(this_arg_conv->sync_routing_table)(this_arg_conv->this_arg, their_node_id_ref, &init_conv);
}
LDKReplyChannelRange msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ReplyChannelRange_clone(&msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = (this_arg_conv->handle_reply_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
LDKReplyShortChannelIdsEnd msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ReplyShortChannelIdsEnd_clone(&msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = (this_arg_conv->handle_reply_short_channel_ids_end)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
LDKQueryChannelRange msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = QueryChannelRange_clone(&msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = (this_arg_conv->handle_query_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
LDKQueryShortChannelIds msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = QueryShortChannelIds_clone(&msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = (this_arg_conv->handle_query_short_channel_ids)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_COption_TypeZDecodeErrorZ ret_conv = *(LDKCResult_COption_TypeZDecodeErrorZ*)(ret_ptr);
- ret_conv = CResult_COption_TypeZDecodeErrorZ_clone((LDKCResult_COption_TypeZDecodeErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
void* ret_conv_25_ptr = (void*)(((uint64_t)ret_conv_25) & ~1);
CHECK_ACCESS(ret_conv_25_ptr);
LDKC2Tuple_PublicKeyTypeZ ret_conv_25_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(ret_conv_25_ptr);
- ret_conv_25_conv = C2Tuple_PublicKeyTypeZ_clone((LDKC2Tuple_PublicKeyTypeZ*)(((uint64_t)ret_conv_25) & ~1));
+ FREE((void*)ret_conv_25);
ret_constr.data[z] = ret_conv_25_conv;
}
(*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
source_var = NodeId_clone(source);
CHECK((((uint64_t)source_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&source_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(source_var);
source_ref = (uint64_t)source_var.inner;
if (source_var.is_owned) {
source_ref |= 1;
target_var = NodeId_clone(target);
CHECK((((uint64_t)target_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&target_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(target_var);
target_ref = (uint64_t)target_var.inner;
if (target_var.is_owned) {
target_ref |= 1;
uint64_t path_conv_10_ref = 0;
CHECK((((uint64_t)path_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&path_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
path_conv_10_ref = (uint64_t)path_conv_10_var.inner;
if (path_conv_10_var.is_owned) {
path_conv_10_ref |= 1;
LDKNodeId source_conv;
source_conv.inner = (void*)(source & (~1));
source_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(source_conv);
LDKNodeId target_conv;
target_conv.inner = (void*)(target & (~1));
target_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
int64_t ret_val = (this_arg_conv->channel_penalty_msat)(this_arg_conv->this_arg, short_channel_id, &source_conv, &target_conv);
return ret_val;
}
LDKRouteHop path_conv_10_conv;
path_conv_10_conv.inner = (void*)(path_conv_10 & (~1));
path_conv_10_conv.is_owned = (path_conv_10 & 1) || (path_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
path_constr.data[k] = path_conv_10_conv;
}
// Warning: we may need a move here but no clone is available for LDKChannelManager
CHECK((((uint64_t)channel_manager_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&channel_manager_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_manager_var);
channel_manager_ref = (uint64_t)channel_manager_var.inner;
if (channel_manager_var.is_owned) {
channel_manager_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneErrorZ ret_conv = *(LDKCResult_NoneErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneErrorZ_clone((LDKCResult_NoneErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
LDKChannelManager channel_manager_conv;
channel_manager_conv.inner = (void*)(channel_manager & (~1));
channel_manager_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_manager_conv);
LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
*ret_conv = (this_arg_conv->persist_manager)(this_arg_conv->this_arg, &channel_manager_conv);
return (uint64_t)ret_conv;
LDKChannelDetails ret_conv_16_conv;
ret_conv_16_conv.inner = (void*)(ret_conv_16 & (~1));
ret_conv_16_conv.is_owned = (ret_conv_16 & 1) || (ret_conv_16 == 0);
- ret_conv_16_conv = ChannelDetails_clone(&ret_conv_16_conv);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_conv);
ret_constr.data[q] = ret_conv_16_conv;
}
(*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
route_var = Route_clone(route);
CHECK((((uint64_t)route_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&route_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_var);
route_ref = (uint64_t)route_var.inner;
if (route_var.is_owned) {
route_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_PaymentIdPaymentSendFailureZ ret_conv = *(LDKCResult_PaymentIdPaymentSendFailureZ*)(ret_ptr);
- ret_conv = CResult_PaymentIdPaymentSendFailureZ_clone((LDKCResult_PaymentIdPaymentSendFailureZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
route_var = Route_clone(route);
CHECK((((uint64_t)route_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&route_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_var);
route_ref = (uint64_t)route_var.inner;
if (route_var.is_owned) {
route_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NonePaymentSendFailureZ ret_conv = *(LDKCResult_NonePaymentSendFailureZ*)(ret_ptr);
- ret_conv = CResult_NonePaymentSendFailureZ_clone((LDKCResult_NonePaymentSendFailureZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
uint64_t ret_conv_16_ref = 0;
CHECK((((uint64_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
ret_conv_16_ref = (uint64_t)ret_conv_16_var.inner;
if (ret_conv_16_var.is_owned) {
ret_conv_16_ref |= 1;
LDKRoute route_conv;
route_conv.inner = (void*)(route & (~1));
route_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
LDKThirtyTwoBytes payment_hash_ref;
CHECK((*env)->GetArrayLength(env, payment_hash) == 32);
(*env)->GetByteArrayRegion(env, payment_hash, 0, 32, payment_hash_ref.data);
LDKRoute route_conv;
route_conv.inner = (void*)(route & (~1));
route_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
LDKThirtyTwoBytes payment_id_ref;
CHECK((*env)->GetArrayLength(env, payment_id) == 32);
(*env)->GetByteArrayRegion(env, payment_id, 0, 32, payment_id_ref.data);
params_var = RouteParameters_clone(params);
CHECK((((uint64_t)params_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)¶ms_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(params_var);
params_ref = (uint64_t)params_var.inner;
if (params_var.is_owned) {
params_ref |= 1;
uint64_t first_hops_conv_16_ref = 0;
CHECK((((uint64_t)first_hops_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&first_hops_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_var);
first_hops_conv_16_ref = (uint64_t)first_hops_conv_16_var.inner;
if (first_hops_conv_16_var.is_owned) {
first_hops_conv_16_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_RouteLightningErrorZ ret_conv = *(LDKCResult_RouteLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_RouteLightningErrorZ_clone((LDKCResult_RouteLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
LDKRouteParameters params_conv;
params_conv.inner = (void*)(params & (~1));
params_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
LDKCVec_ChannelDetailsZ first_hops_constr;
LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL;
if (first_hops != NULL) {
LDKChannelDetails first_hops_conv_16_conv;
first_hops_conv_16_conv.inner = (void*)(first_hops_conv_16 & (~1));
first_hops_conv_16_conv.is_owned = (first_hops_conv_16 & 1) || (first_hops_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_conv);
first_hops_constr.data[q] = first_hops_conv_16_conv;
}
(*env)->ReleaseLongArrayElements(env, first_hops, first_hops_vals, 0);
TxOut_free(_res_conv);
}
+static inline uint64_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg) {
+ LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
+ *ret_ref = TxOut_clone(arg);
+ return (uint64_t)ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_TxOut_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKTxOut* arg_conv = (LDKTxOut*)(arg & ~1);
+ int64_t ret_val = TxOut_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_TxOut_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKTxOut* orig_conv = (LDKTxOut*)(orig & ~1);
LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1SecretKeyErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_SecretKeyErrorZ* o_conv = (LDKCResult_SecretKeyErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_SecretKeyErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SecretKeyErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PublicKeyErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_PublicKeyErrorZ* o_conv = (LDKCResult_PublicKeyErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PublicKeyErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PublicKeyErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PublicKeyErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
+ *ret_conv = CResult_PublicKeyErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PublicKeyErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_PublicKeyErrorZ* arg_conv = (LDKCResult_PublicKeyErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PublicKeyErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PublicKeyErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_PublicKeyErrorZ* orig_conv = (LDKCResult_PublicKeyErrorZ*)(orig & ~1);
LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
LDKTxCreationKeys o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = TxCreationKeys_clone(&o_conv);
LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
*ret_conv = CResult_TxCreationKeysDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
*ret_conv = CResult_TxCreationKeysDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_TxCreationKeysDecodeErrorZ* o_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_TxCreationKeysDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_TxCreationKeysDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
+ *ret_conv = CResult_TxCreationKeysDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_TxCreationKeysDecodeErrorZ* arg_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_TxCreationKeysDecodeErrorZ* orig_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)(orig & ~1);
LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
LDKChannelPublicKeys o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelPublicKeys_clone(&o_conv);
LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
*ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
*ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelPublicKeysDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ChannelPublicKeysDecodeErrorZ* o_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelPublicKeysDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelPublicKeysDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
+ *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelPublicKeysDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ChannelPublicKeysDecodeErrorZ* arg_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelPublicKeysDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ChannelPublicKeysDecodeErrorZ* orig_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
LDKTxCreationKeys o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = TxCreationKeys_clone(&o_conv);
LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
*ret_conv = CResult_TxCreationKeysErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_TxCreationKeysErrorZ* o_conv = (LDKCResult_TxCreationKeysErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_TxCreationKeysErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_TxCreationKeysErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_TxCreationKeysErrorZ_clone_ptr(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR arg) {
+ LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
+ *ret_conv = CResult_TxCreationKeysErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_TxCreationKeysErrorZ* arg_conv = (LDKCResult_TxCreationKeysErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_TxCreationKeysErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_TxCreationKeysErrorZ* orig_conv = (LDKCResult_TxCreationKeysErrorZ*)(orig & ~1);
LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
COption_u32Z_free(_res_conv);
}
+static inline uint64_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg) {
+ LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
+ *ret_copy = COption_u32Z_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1u32Z_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCOption_u32Z* arg_conv = (LDKCOption_u32Z*)arg;
+ int64_t ret_val = COption_u32Z_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1u32Z_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCOption_u32Z* orig_conv = (LDKCOption_u32Z*)orig;
LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
LDKHTLCOutputInCommitment o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = HTLCOutputInCommitment_clone(&o_conv);
LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
*ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
*ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCOutputInCommitmentDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* o_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCOutputInCommitmentDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
+ *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCOutputInCommitmentDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* arg_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCOutputInCommitmentDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* orig_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(orig & ~1);
LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
LDKCounterpartyChannelTransactionParameters o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = CounterpartyChannelTransactionParameters_clone(&o_conv);
LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
*ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
*ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* o_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
+ *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* arg_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(orig & ~1);
LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
LDKChannelTransactionParameters o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelTransactionParameters_clone(&o_conv);
LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
*ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
*ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelTransactionParametersDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ChannelTransactionParametersDecodeErrorZ* o_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelTransactionParametersDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelTransactionParametersDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
+ *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelTransactionParametersDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ChannelTransactionParametersDecodeErrorZ* arg_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelTransactionParametersDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
LDKHolderCommitmentTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = HolderCommitmentTransaction_clone(&o_conv);
LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1HolderCommitmentTransactionDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_HolderCommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1HolderCommitmentTransactionDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
+ *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HolderCommitmentTransactionDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_HolderCommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HolderCommitmentTransactionDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_HolderCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(orig & ~1);
LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
LDKBuiltCommitmentTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = BuiltCommitmentTransaction_clone(&o_conv);
LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1BuiltCommitmentTransactionDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1BuiltCommitmentTransactionDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
+ *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1BuiltCommitmentTransactionDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1BuiltCommitmentTransactionDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(orig & ~1);
LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
LDKTrustedClosingTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
// Warning: we need a move here but no clone is available for LDKTrustedClosingTransaction
LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
*ret_conv = CResult_TrustedClosingTransactionNoneZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedClosingTransactionNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_TrustedClosingTransactionNoneZ* o_conv = (LDKCResult_TrustedClosingTransactionNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_TrustedClosingTransactionNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedClosingTransactionNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKCommitmentTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = CommitmentTransaction_clone(&o_conv);
LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_CommitmentTransactionDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_CommitmentTransactionDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentTransactionDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_CommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CommitmentTransactionDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentTransactionDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CommitmentTransactionDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
+ *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentTransactionDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_CommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentTransactionDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_CommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(orig & ~1);
LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
LDKTrustedCommitmentTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
// Warning: we need a move here but no clone is available for LDKTrustedCommitmentTransaction
LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
*ret_conv = CResult_TrustedCommitmentTransactionNoneZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedCommitmentTransactionNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_TrustedCommitmentTransactionNoneZ* o_conv = (LDKCResult_TrustedCommitmentTransactionNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_TrustedCommitmentTransactionNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedCommitmentTransactionNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_CVec_SignatureZNoneZ* o_conv = (LDKCResult_CVec_SignatureZNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_CVec_SignatureZNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CVec_SignatureZNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg) {
+ LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
+ *ret_conv = CResult_CVec_SignatureZNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_CVec_SignatureZNoneZ* arg_conv = (LDKCResult_CVec_SignatureZNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_CVec_SignatureZNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_CVec_SignatureZNoneZ* orig_conv = (LDKCResult_CVec_SignatureZNoneZ*)(orig & ~1);
LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
LDKShutdownScript o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ShutdownScript_clone(&o_conv);
LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
*ret_conv = CResult_ShutdownScriptDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
*ret_conv = CResult_ShutdownScriptDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ShutdownScriptDecodeErrorZ* o_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ShutdownScriptDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ShutdownScriptDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
+ *ret_conv = CResult_ShutdownScriptDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ShutdownScriptDecodeErrorZ* arg_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ShutdownScriptDecodeErrorZ* orig_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)(orig & ~1);
LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
LDKShutdownScript o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ShutdownScript_clone(&o_conv);
LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
*ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o_conv);
LDKInvalidShutdownScript e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = InvalidShutdownScript_clone(&e_conv);
LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
*ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptInvalidShutdownScriptZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ShutdownScriptInvalidShutdownScriptZ* o_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(o & ~1);
+ jboolean ret_val = CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptInvalidShutdownScriptZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res_conv);
}
+static inline uint64_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg) {
+ LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
+ *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptInvalidShutdownScriptZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ShutdownScriptInvalidShutdownScriptZ* arg_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(arg & ~1);
+ int64_t ret_val = CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptInvalidShutdownScriptZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ShutdownScriptInvalidShutdownScriptZ* orig_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(orig & ~1);
LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NoneErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NoneErrorZ* o_conv = (LDKCResult_NoneErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
+ *ret_conv = CResult_NoneErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NoneErrorZ* arg_conv = (LDKCResult_NoneErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NoneErrorZ* orig_conv = (LDKCResult_NoneErrorZ*)(orig & ~1);
LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
LDKRouteHop o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RouteHop_clone(&o_conv);
LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
*ret_conv = CResult_RouteHopDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
*ret_conv = CResult_RouteHopDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHopDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_RouteHopDecodeErrorZ* o_conv = (LDKCResult_RouteHopDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteHopDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHopDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RouteHopDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
+ *ret_conv = CResult_RouteHopDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHopDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_RouteHopDecodeErrorZ* arg_conv = (LDKCResult_RouteHopDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteHopDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHopDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_RouteHopDecodeErrorZ* orig_conv = (LDKCResult_RouteHopDecodeErrorZ*)(orig & ~1);
LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
LDKRouteHop _res_conv_10_conv;
_res_conv_10_conv.inner = (void*)(_res_conv_10 & (~1));
_res_conv_10_conv.is_owned = (_res_conv_10 & 1) || (_res_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_10_conv);
_res_constr.data[k] = _res_conv_10_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
LDKRouteHop _res_conv_12_conv_10_conv;
_res_conv_12_conv_10_conv.inner = (void*)(_res_conv_12_conv_10 & (~1));
_res_conv_12_conv_10_conv.is_owned = (_res_conv_12_conv_10 & 1) || (_res_conv_12_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_12_conv_10_conv);
_res_conv_12_constr.data[k] = _res_conv_12_conv_10_conv;
}
(*env)->ReleaseLongArrayElements(env, _res_conv_12, _res_conv_12_vals, 0);
LDKRoute o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Route_clone(&o_conv);
LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
*ret_conv = CResult_RouteDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
*ret_conv = CResult_RouteDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RouteDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_RouteDecodeErrorZ* o_conv = (LDKCResult_RouteDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RouteDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
+ *ret_conv = CResult_RouteDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_RouteDecodeErrorZ* arg_conv = (LDKCResult_RouteDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_RouteDecodeErrorZ* orig_conv = (LDKCResult_RouteDecodeErrorZ*)(orig & ~1);
LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
LDKRouteParameters o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RouteParameters_clone(&o_conv);
LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
*ret_conv = CResult_RouteParametersDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
*ret_conv = CResult_RouteParametersDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RouteParametersDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_RouteParametersDecodeErrorZ* o_conv = (LDKCResult_RouteParametersDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteParametersDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteParametersDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RouteParametersDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
+ *ret_conv = CResult_RouteParametersDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteParametersDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_RouteParametersDecodeErrorZ* arg_conv = (LDKCResult_RouteParametersDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteParametersDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteParametersDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_RouteParametersDecodeErrorZ* orig_conv = (LDKCResult_RouteParametersDecodeErrorZ*)(orig & ~1);
LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
LDKRouteHint _res_conv_11_conv;
_res_conv_11_conv.inner = (void*)(_res_conv_11 & (~1));
_res_conv_11_conv.is_owned = (_res_conv_11 & 1) || (_res_conv_11 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_11_conv);
_res_constr.data[l] = _res_conv_11_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
COption_u64Z_free(_res_conv);
}
+static inline uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg) {
+ LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
+ *ret_copy = COption_u64Z_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1u64Z_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCOption_u64Z* arg_conv = (LDKCOption_u64Z*)arg;
+ int64_t ret_val = COption_u64Z_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1u64Z_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCOption_u64Z* orig_conv = (LDKCOption_u64Z*)orig;
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
LDKPayee o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Payee_clone(&o_conv);
LDKCResult_PayeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeeDecodeErrorZ), "LDKCResult_PayeeDecodeErrorZ");
*ret_conv = CResult_PayeeDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_PayeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeeDecodeErrorZ), "LDKCResult_PayeeDecodeErrorZ");
*ret_conv = CResult_PayeeDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PayeeDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_PayeeDecodeErrorZ* o_conv = (LDKCResult_PayeeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PayeeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PayeeDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PayeeDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PayeeDecodeErrorZ_clone_ptr(LDKCResult_PayeeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PayeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeeDecodeErrorZ), "LDKCResult_PayeeDecodeErrorZ");
+ *ret_conv = CResult_PayeeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PayeeDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_PayeeDecodeErrorZ* arg_conv = (LDKCResult_PayeeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PayeeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PayeeDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_PayeeDecodeErrorZ* orig_conv = (LDKCResult_PayeeDecodeErrorZ*)(orig & ~1);
LDKCResult_PayeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeeDecodeErrorZ), "LDKCResult_PayeeDecodeErrorZ");
LDKRouteHintHop _res_conv_14_conv;
_res_conv_14_conv.inner = (void*)(_res_conv_14 & (~1));
_res_conv_14_conv.is_owned = (_res_conv_14 & 1) || (_res_conv_14 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_14_conv);
_res_constr.data[o] = _res_conv_14_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
LDKRouteHint o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RouteHint_clone(&o_conv);
LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
*ret_conv = CResult_RouteHintDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
*ret_conv = CResult_RouteHintDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_RouteHintDecodeErrorZ* o_conv = (LDKCResult_RouteHintDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteHintDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RouteHintDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
+ *ret_conv = CResult_RouteHintDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_RouteHintDecodeErrorZ* arg_conv = (LDKCResult_RouteHintDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteHintDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_RouteHintDecodeErrorZ* orig_conv = (LDKCResult_RouteHintDecodeErrorZ*)(orig & ~1);
LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
LDKRouteHintHop o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RouteHintHop_clone(&o_conv);
LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
*ret_conv = CResult_RouteHintHopDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
*ret_conv = CResult_RouteHintHopDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintHopDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_RouteHintHopDecodeErrorZ* o_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteHintHopDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintHopDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RouteHintHopDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
+ *ret_conv = CResult_RouteHintHopDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintHopDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_RouteHintHopDecodeErrorZ* arg_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintHopDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_RouteHintHopDecodeErrorZ* orig_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)(orig & ~1);
LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
LDKChannelDetails _res_conv_16_conv;
_res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
_res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
_res_constr.data[q] = _res_conv_16_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
LDKRoute o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Route_clone(&o_conv);
LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
*ret_conv = CResult_RouteLightningErrorZ_ok(o_conv);
LDKLightningError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = LightningError_clone(&e_conv);
LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
*ret_conv = CResult_RouteLightningErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RouteLightningErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_RouteLightningErrorZ* o_conv = (LDKCResult_RouteLightningErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteLightningErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteLightningErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RouteLightningErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
+ *ret_conv = CResult_RouteLightningErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteLightningErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_RouteLightningErrorZ* arg_conv = (LDKCResult_RouteLightningErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteLightningErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteLightningErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_RouteLightningErrorZ* orig_conv = (LDKCResult_RouteLightningErrorZ*)(orig & ~1);
LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1TxOutAccessErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_TxOutAccessErrorZ* o_conv = (LDKCResult_TxOutAccessErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_TxOutAccessErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TxOutAccessErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_TxOutAccessErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg) {
+ LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
+ *ret_conv = CResult_TxOutAccessErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxOutAccessErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_TxOutAccessErrorZ* arg_conv = (LDKCResult_TxOutAccessErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_TxOutAccessErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxOutAccessErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_TxOutAccessErrorZ* orig_conv = (LDKCResult_TxOutAccessErrorZ*)(orig & ~1);
LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg) {
+ LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
+ *ret_conv = C2Tuple_usizeTransactionZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1usizeTransactionZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC2Tuple_usizeTransactionZ* arg_conv = (LDKC2Tuple_usizeTransactionZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_usizeTransactionZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1usizeTransactionZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC2Tuple_usizeTransactionZ* orig_conv = (LDKC2Tuple_usizeTransactionZ*)(orig & ~1);
LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NoneChannelMonitorUpdateErrZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NoneChannelMonitorUpdateErrZ* o_conv = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneChannelMonitorUpdateErrZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneChannelMonitorUpdateErrZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneChannelMonitorUpdateErrZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR arg) {
+ LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
+ *ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneChannelMonitorUpdateErrZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NoneChannelMonitorUpdateErrZ* arg_conv = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneChannelMonitorUpdateErrZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NoneChannelMonitorUpdateErrZ* orig_conv = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(orig & ~1);
LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
COption_C2Tuple_usizeTransactionZZ_free(_res_conv);
}
+static inline uint64_t COption_C2Tuple_usizeTransactionZZ_clone_ptr(LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR arg) {
+ LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
+ *ret_copy = COption_C2Tuple_usizeTransactionZZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1C2Tuple_1usizeTransactionZZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCOption_C2Tuple_usizeTransactionZZ* arg_conv = (LDKCOption_C2Tuple_usizeTransactionZZ*)arg;
+ int64_t ret_val = COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1C2Tuple_1usizeTransactionZZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCOption_C2Tuple_usizeTransactionZZ* orig_conv = (LDKCOption_C2Tuple_usizeTransactionZZ*)orig;
LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
return ret_ref;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1ClosureReasonZ_1some(JNIEnv *env, jclass clz, int64_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKClosureReason o_conv = *(LDKClosureReason*)(o_ptr);
+ o_conv = ClosureReason_clone((LDKClosureReason*)(((uint64_t)o) & ~1));
+ LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
+ *ret_copy = COption_ClosureReasonZ_some(o_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1ClosureReasonZ_1none(JNIEnv *env, jclass clz) {
+ LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
+ *ret_copy = COption_ClosureReasonZ_none();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1ClosureReasonZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_ClosureReasonZ _res_conv = *(LDKCOption_ClosureReasonZ*)(_res_ptr);
+ FREE((void*)_res);
+ COption_ClosureReasonZ_free(_res_conv);
+}
+
+static inline uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg) {
+ LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
+ *ret_copy = COption_ClosureReasonZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1ClosureReasonZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCOption_ClosureReasonZ* arg_conv = (LDKCOption_ClosureReasonZ*)arg;
+ int64_t ret_val = COption_ClosureReasonZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1ClosureReasonZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+ LDKCOption_ClosureReasonZ* orig_conv = (LDKCOption_ClosureReasonZ*)orig;
+ LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
+ *ret_copy = COption_ClosureReasonZ_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1ClosureReasonZDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKCOption_ClosureReasonZ o_conv = *(LDKCOption_ClosureReasonZ*)(o_ptr);
+ o_conv = COption_ClosureReasonZ_clone((LDKCOption_ClosureReasonZ*)(((uint64_t)o) & ~1));
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1ClosureReasonZDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1ClosureReasonZDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* o_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1ClosureReasonZDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ _res_conv = *(LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_COption_ClosureReasonZDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1ClosureReasonZDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* arg_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1ClosureReasonZDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* orig_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(orig & ~1);
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1NetworkUpdateZ_1some(JNIEnv *env, jclass clz, int64_t o) {
void* o_ptr = (void*)(((uint64_t)o) & ~1);
CHECK_ACCESS(o_ptr);
COption_NetworkUpdateZ_free(_res_conv);
}
+static inline uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg) {
+ LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
+ *ret_copy = COption_NetworkUpdateZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1NetworkUpdateZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCOption_NetworkUpdateZ* arg_conv = (LDKCOption_NetworkUpdateZ*)arg;
+ int64_t ret_val = COption_NetworkUpdateZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1NetworkUpdateZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCOption_NetworkUpdateZ* orig_conv = (LDKCOption_NetworkUpdateZ*)orig;
LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
CVec_SpendableOutputDescriptorZ_free(_res_constr);
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1EventZ_1some(JNIEnv *env, jclass clz, int64_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKEvent o_conv = *(LDKEvent*)(o_ptr);
+ o_conv = Event_clone((LDKEvent*)(((uint64_t)o) & ~1));
+ LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
+ *ret_copy = COption_EventZ_some(o_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1EventZ_1none(JNIEnv *env, jclass clz) {
+ LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
+ *ret_copy = COption_EventZ_none();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1EventZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_EventZ _res_conv = *(LDKCOption_EventZ*)(_res_ptr);
+ FREE((void*)_res);
+ COption_EventZ_free(_res_conv);
+}
+
+static inline uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg) {
+ LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
+ *ret_copy = COption_EventZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1EventZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCOption_EventZ* arg_conv = (LDKCOption_EventZ*)arg;
+ int64_t ret_val = COption_EventZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1EventZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+ LDKCOption_EventZ* orig_conv = (LDKCOption_EventZ*)orig;
+ LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
+ *ret_copy = COption_EventZ_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1EventZDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKCOption_EventZ o_conv = *(LDKCOption_EventZ*)(o_ptr);
+ o_conv = COption_EventZ_clone((LDKCOption_EventZ*)(((uint64_t)o) & ~1));
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = CResult_COption_EventZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1EventZDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = CResult_COption_EventZDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1EventZDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_COption_EventZDecodeErrorZ* o_conv = (LDKCResult_COption_EventZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_EventZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1EventZDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_COption_EventZDecodeErrorZ _res_conv = *(LDKCResult_COption_EventZDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_COption_EventZDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = CResult_COption_EventZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1EventZDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_EventZDecodeErrorZ* arg_conv = (LDKCResult_COption_EventZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_EventZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1EventZDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+ LDKCResult_COption_EventZDecodeErrorZ* orig_conv = (LDKCResult_COption_EventZDecodeErrorZ*)(orig & ~1);
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = CResult_COption_EventZDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1MessageSendEventZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
LDKCVec_MessageSendEventZ _res_constr;
_res_constr.datalen = (*env)->GetArrayLength(env, _res);
LDKInitFeatures o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = InitFeatures_clone(&o_conv);
LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
*ret_conv = CResult_InitFeaturesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
*ret_conv = CResult_InitFeaturesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1InitFeaturesDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_InitFeaturesDecodeErrorZ* o_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InitFeaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InitFeaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKNodeFeatures o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NodeFeatures_clone(&o_conv);
LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
*ret_conv = CResult_NodeFeaturesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
*ret_conv = CResult_NodeFeaturesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NodeFeaturesDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NodeFeaturesDecodeErrorZ* o_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeFeaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeFeaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKChannelFeatures o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelFeatures_clone(&o_conv);
LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
*ret_conv = CResult_ChannelFeaturesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
*ret_conv = CResult_ChannelFeaturesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelFeaturesDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ChannelFeaturesDecodeErrorZ* o_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelFeaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelFeaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKInvoiceFeatures o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = InvoiceFeatures_clone(&o_conv);
LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
*ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
*ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceFeaturesDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_InvoiceFeaturesDecodeErrorZ* o_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceFeaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKScoringParameters o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
// Warning: we need a move here but no clone is available for LDKScoringParameters
LDKCResult_ScoringParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ScoringParametersDecodeErrorZ), "LDKCResult_ScoringParametersDecodeErrorZ");
*ret_conv = CResult_ScoringParametersDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ScoringParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ScoringParametersDecodeErrorZ), "LDKCResult_ScoringParametersDecodeErrorZ");
*ret_conv = CResult_ScoringParametersDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ScoringParametersDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ScoringParametersDecodeErrorZ* o_conv = (LDKCResult_ScoringParametersDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ScoringParametersDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ScoringParametersDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKScorer o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
// Warning: we need a move here but no clone is available for LDKScorer
LDKCResult_ScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ScorerDecodeErrorZ), "LDKCResult_ScorerDecodeErrorZ");
*ret_conv = CResult_ScorerDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ScorerDecodeErrorZ), "LDKCResult_ScorerDecodeErrorZ");
*ret_conv = CResult_ScorerDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ScorerDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ScorerDecodeErrorZ* o_conv = (LDKCResult_ScorerDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ScorerDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ScorerDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKDelayedPaymentOutputDescriptor o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = DelayedPaymentOutputDescriptor_clone(&o_conv);
LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
*ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
*ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(orig & ~1);
LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
LDKStaticPaymentOutputDescriptor o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = StaticPaymentOutputDescriptor_clone(&o_conv);
LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
*ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
*ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(orig & ~1);
LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
*ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1SpendableOutputDescriptorDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SpendableOutputDescriptorDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SpendableOutputDescriptorDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SpendableOutputDescriptorDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_SpendableOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(orig & ~1);
LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NoneNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NoneNoneZ* o_conv = (LDKCResult_NoneNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg) {
+ LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
+ *ret_conv = CResult_NoneNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneNoneZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NoneNoneZ* arg_conv = (LDKCResult_NoneNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NoneNoneZ* orig_conv = (LDKCResult_NoneNoneZ*)(orig & ~1);
LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg) {
+ LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
+ *ret_conv = C2Tuple_SignatureCVec_SignatureZZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1SignatureCVec_1SignatureZZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC2Tuple_SignatureCVec_SignatureZZ* arg_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1SignatureCVec_1SignatureZZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC2Tuple_SignatureCVec_SignatureZZ* orig_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(orig & ~1);
LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* o_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg) {
+ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
+ *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* arg_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* orig_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(orig & ~1);
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1SignatureNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_SignatureNoneZ* o_conv = (LDKCResult_SignatureNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_SignatureNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SignatureNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_SignatureNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg) {
+ LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
+ *ret_conv = CResult_SignatureNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignatureNoneZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_SignatureNoneZ* arg_conv = (LDKCResult_SignatureNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_SignatureNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignatureNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_SignatureNoneZ* orig_conv = (LDKCResult_SignatureNoneZ*)(orig & ~1);
LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
*ret_conv = CResult_SignDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1SignDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_SignDecodeErrorZ* o_conv = (LDKCResult_SignDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_SignDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SignDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_SignDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
+ *ret_conv = CResult_SignDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_SignDecodeErrorZ* arg_conv = (LDKCResult_SignDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_SignDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_SignDecodeErrorZ* orig_conv = (LDKCResult_SignDecodeErrorZ*)(orig & ~1);
LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RecoverableSignatureNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_RecoverableSignatureNoneZ* o_conv = (LDKCResult_RecoverableSignatureNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_RecoverableSignatureNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RecoverableSignatureNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RecoverableSignatureNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg) {
+ LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
+ *ret_conv = CResult_RecoverableSignatureNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RecoverableSignatureNoneZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_RecoverableSignatureNoneZ* arg_conv = (LDKCResult_RecoverableSignatureNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_RecoverableSignatureNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RecoverableSignatureNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_RecoverableSignatureNoneZ* orig_conv = (LDKCResult_RecoverableSignatureNoneZ*)(orig & ~1);
LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1CVec_1u8ZZNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_CVec_CVec_u8ZZNoneZ* o_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_CVec_CVec_u8ZZNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1CVec_1u8ZZNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CVec_CVec_u8ZZNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg) {
+ LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
+ *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1CVec_1u8ZZNoneZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_CVec_CVec_u8ZZNoneZ* arg_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1CVec_1u8ZZNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_CVec_CVec_u8ZZNoneZ* orig_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(orig & ~1);
LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
LDKInMemorySigner o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = InMemorySigner_clone(&o_conv);
LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
*ret_conv = CResult_InMemorySignerDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
*ret_conv = CResult_InMemorySignerDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1InMemorySignerDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_InMemorySignerDecodeErrorZ* o_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InMemorySignerDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InMemorySignerDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_InMemorySignerDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
+ *ret_conv = CResult_InMemorySignerDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InMemorySignerDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_InMemorySignerDecodeErrorZ* arg_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InMemorySignerDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_InMemorySignerDecodeErrorZ* orig_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(orig & ~1);
LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1TransactionNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_TransactionNoneZ* o_conv = (LDKCResult_TransactionNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_TransactionNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TransactionNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_TransactionNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg) {
+ LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
+ *ret_conv = CResult_TransactionNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TransactionNoneZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_TransactionNoneZ* arg_conv = (LDKCResult_TransactionNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_TransactionNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TransactionNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_TransactionNoneZ* orig_conv = (LDKCResult_TransactionNoneZ*)(orig & ~1);
LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg) {
+ LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
+ *ret_conv = C2Tuple_BlockHashChannelMonitorZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1BlockHashChannelMonitorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC2Tuple_BlockHashChannelMonitorZ* arg_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1BlockHashChannelMonitorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC2Tuple_BlockHashChannelMonitorZ* orig_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)(orig & ~1);
LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
LDKChannelMonitor b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = (b & 1) || (b == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
b_conv = ChannelMonitor_clone(&b_conv);
LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
*ret_conv = C2Tuple_BlockHashChannelMonitorZ_new(a_ref, b_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* o_conv = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone_ptr(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ), "LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ");
+ *ret_conv = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* arg_conv = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* orig_conv = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(orig & ~1);
LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ), "LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ");
COption_u16Z_free(_res_conv);
}
+static inline uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg) {
+ LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
+ *ret_copy = COption_u16Z_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1u16Z_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCOption_u16Z* arg_conv = (LDKCOption_u16Z*)arg;
+ int64_t ret_val = COption_u16Z_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1u16Z_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCOption_u16Z* orig_conv = (LDKCOption_u16Z*)orig;
LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NoneAPIErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NoneAPIErrorZ* o_conv = (LDKCResult_NoneAPIErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneAPIErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneAPIErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneAPIErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
+ *ret_conv = CResult_NoneAPIErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneAPIErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NoneAPIErrorZ* arg_conv = (LDKCResult_NoneAPIErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneAPIErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneAPIErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NoneAPIErrorZ* orig_conv = (LDKCResult_NoneAPIErrorZ*)(orig & ~1);
LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1_1u832APIErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult__u832APIErrorZ* o_conv = (LDKCResult__u832APIErrorZ*)(o & ~1);
+ jboolean ret_val = CResult__u832APIErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1_1u832APIErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult__u832APIErrorZ_free(_res_conv);
}
+static inline uint64_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg) {
+ LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
+ *ret_conv = CResult__u832APIErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1_1u832APIErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult__u832APIErrorZ* arg_conv = (LDKCResult__u832APIErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult__u832APIErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1_1u832APIErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult__u832APIErrorZ* orig_conv = (LDKCResult__u832APIErrorZ*)(orig & ~1);
LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentSendFailureZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_PaymentIdPaymentSendFailureZ* o_conv = (LDKCResult_PaymentIdPaymentSendFailureZ*)(o & ~1);
+ jboolean ret_val = CResult_PaymentIdPaymentSendFailureZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentSendFailureZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PaymentIdPaymentSendFailureZ_free(_res_conv);
}
+static inline uint64_t CResult_PaymentIdPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR arg) {
+ LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ");
+ *ret_conv = CResult_PaymentIdPaymentSendFailureZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentSendFailureZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_PaymentIdPaymentSendFailureZ* arg_conv = (LDKCResult_PaymentIdPaymentSendFailureZ*)(arg & ~1);
+ int64_t ret_val = CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentSendFailureZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_PaymentIdPaymentSendFailureZ* orig_conv = (LDKCResult_PaymentIdPaymentSendFailureZ*)(orig & ~1);
LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NonePaymentSendFailureZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NonePaymentSendFailureZ* o_conv = (LDKCResult_NonePaymentSendFailureZ*)(o & ~1);
+ jboolean ret_val = CResult_NonePaymentSendFailureZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NonePaymentSendFailureZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NonePaymentSendFailureZ_free(_res_conv);
}
+static inline uint64_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg) {
+ LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
+ *ret_conv = CResult_NonePaymentSendFailureZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NonePaymentSendFailureZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NonePaymentSendFailureZ* arg_conv = (LDKCResult_NonePaymentSendFailureZ*)(arg & ~1);
+ int64_t ret_val = CResult_NonePaymentSendFailureZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NonePaymentSendFailureZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NonePaymentSendFailureZ* orig_conv = (LDKCResult_NonePaymentSendFailureZ*)(orig & ~1);
LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg) {
+ LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
+ *ret_conv = C2Tuple_PaymentHashPaymentIdZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1PaymentHashPaymentIdZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC2Tuple_PaymentHashPaymentIdZ* arg_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1PaymentHashPaymentIdZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC2Tuple_PaymentHashPaymentIdZ* orig_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)(orig & ~1);
LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1PaymentHashPaymentIdZPaymentSendFailureZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* o_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(o & ~1);
+ jboolean ret_val = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1PaymentHashPaymentIdZPaymentSendFailureZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res_conv);
}
+static inline uint64_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg) {
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
+ *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1PaymentHashPaymentIdZPaymentSendFailureZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* arg_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(arg & ~1);
+ int64_t ret_val = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1PaymentHashPaymentIdZPaymentSendFailureZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* orig_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(orig & ~1);
LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
CVec_NetAddressZ_free(_res_constr);
}
+static inline uint64_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg) {
+ LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
+ *ret_conv = C2Tuple_PaymentHashPaymentSecretZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1PaymentHashPaymentSecretZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC2Tuple_PaymentHashPaymentSecretZ* arg_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1PaymentHashPaymentSecretZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC2Tuple_PaymentHashPaymentSecretZ* orig_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(orig & ~1);
LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentSecretAPIErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_PaymentSecretAPIErrorZ* o_conv = (LDKCResult_PaymentSecretAPIErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PaymentSecretAPIErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentSecretAPIErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PaymentSecretAPIErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
+ *ret_conv = CResult_PaymentSecretAPIErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentSecretAPIErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_PaymentSecretAPIErrorZ* arg_conv = (LDKCResult_PaymentSecretAPIErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PaymentSecretAPIErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentSecretAPIErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_PaymentSecretAPIErrorZ* orig_conv = (LDKCResult_PaymentSecretAPIErrorZ*)(orig & ~1);
LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
LDKChannelMonitor _res_conv_16_conv;
_res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
_res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
_res_constr.data[q] = _res_conv_16_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
LDKChannelManager b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = (b & 1) || (b == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
// Warning: we need a move here but no clone is available for LDKChannelManager
LDKC2Tuple_BlockHashChannelManagerZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelManagerZ), "LDKC2Tuple_BlockHashChannelManagerZ");
*ret_conv = C2Tuple_BlockHashChannelManagerZ_new(a_ref, b_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
*ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* o_conv = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKChannelConfig o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelConfig_clone(&o_conv);
LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
*ret_conv = CResult_ChannelConfigDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
*ret_conv = CResult_ChannelConfigDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ChannelConfigDecodeErrorZ* o_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelConfigDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelConfigDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
+ *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ChannelConfigDecodeErrorZ* arg_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ChannelConfigDecodeErrorZ* orig_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
LDKOutPoint o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = OutPoint_clone(&o_conv);
LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
*ret_conv = CResult_OutPointDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
*ret_conv = CResult_OutPointDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1OutPointDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_OutPointDecodeErrorZ* o_conv = (LDKCResult_OutPointDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_OutPointDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1OutPointDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_OutPointDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
+ *ret_conv = CResult_OutPointDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OutPointDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_OutPointDecodeErrorZ* arg_conv = (LDKCResult_OutPointDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_OutPointDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OutPointDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_OutPointDecodeErrorZ* orig_conv = (LDKCResult_OutPointDecodeErrorZ*)(orig & ~1);
LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
COption_TypeZ_free(_res_conv);
}
+static inline uint64_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg) {
+ LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
+ *ret_copy = COption_TypeZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1TypeZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCOption_TypeZ* arg_conv = (LDKCOption_TypeZ*)arg;
+ int64_t ret_val = COption_TypeZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1TypeZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCOption_TypeZ* orig_conv = (LDKCOption_TypeZ*)orig;
LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
*ret_conv = CResult_COption_TypeZDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1TypeZDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_COption_TypeZDecodeErrorZ* o_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_TypeZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1TypeZDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_COption_TypeZDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
+ *ret_conv = CResult_COption_TypeZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1TypeZDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_TypeZDecodeErrorZ* arg_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1TypeZDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_COption_TypeZDecodeErrorZ* orig_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)(orig & ~1);
LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_PaymentIdPaymentErrorZ* o_conv = (LDKCResult_PaymentIdPaymentErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PaymentIdPaymentErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PaymentIdPaymentErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
+ *ret_conv = CResult_PaymentIdPaymentErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_PaymentIdPaymentErrorZ* arg_conv = (LDKCResult_PaymentIdPaymentErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PaymentIdPaymentErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_PaymentIdPaymentErrorZ* orig_conv = (LDKCResult_PaymentIdPaymentErrorZ*)(orig & ~1);
LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1SiPrefixNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_SiPrefixNoneZ* o_conv = (LDKCResult_SiPrefixNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_SiPrefixNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SiPrefixNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_SiPrefixNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_SiPrefixNoneZ_clone_ptr(LDKCResult_SiPrefixNoneZ *NONNULL_PTR arg) {
+ LDKCResult_SiPrefixNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixNoneZ), "LDKCResult_SiPrefixNoneZ");
+ *ret_conv = CResult_SiPrefixNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SiPrefixNoneZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_SiPrefixNoneZ* arg_conv = (LDKCResult_SiPrefixNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_SiPrefixNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SiPrefixNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_SiPrefixNoneZ* orig_conv = (LDKCResult_SiPrefixNoneZ*)(orig & ~1);
LDKCResult_SiPrefixNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixNoneZ), "LDKCResult_SiPrefixNoneZ");
LDKInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Invoice_clone(&o_conv);
LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
*ret_conv = CResult_InvoiceNoneZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_InvoiceNoneZ* o_conv = (LDKCResult_InvoiceNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_InvoiceNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_InvoiceNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_InvoiceNoneZ_clone_ptr(LDKCResult_InvoiceNoneZ *NONNULL_PTR arg) {
+ LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
+ *ret_conv = CResult_InvoiceNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceNoneZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_InvoiceNoneZ* arg_conv = (LDKCResult_InvoiceNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_InvoiceNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_InvoiceNoneZ* orig_conv = (LDKCResult_InvoiceNoneZ*)(orig & ~1);
LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
LDKSignedRawInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = SignedRawInvoice_clone(&o_conv);
LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
*ret_conv = CResult_SignedRawInvoiceNoneZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1SignedRawInvoiceNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_SignedRawInvoiceNoneZ* o_conv = (LDKCResult_SignedRawInvoiceNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_SignedRawInvoiceNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SignedRawInvoiceNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_SignedRawInvoiceNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_SignedRawInvoiceNoneZ_clone_ptr(LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR arg) {
+ LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
+ *ret_conv = CResult_SignedRawInvoiceNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignedRawInvoiceNoneZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_SignedRawInvoiceNoneZ* arg_conv = (LDKCResult_SignedRawInvoiceNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_SignedRawInvoiceNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignedRawInvoiceNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_SignedRawInvoiceNoneZ* orig_conv = (LDKCResult_SignedRawInvoiceNoneZ*)(orig & ~1);
LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg) {
+ LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
+ *ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C3Tuple_1RawInvoice_1u832InvoiceSignatureZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* arg_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(arg & ~1);
+ int64_t ret_val = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C3Tuple_1RawInvoice_1u832InvoiceSignatureZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* orig_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(orig & ~1);
LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
LDKRawInvoice a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = RawInvoice_clone(&a_conv);
LDKThirtyTwoBytes b_ref;
CHECK((*env)->GetArrayLength(env, b) == 32);
LDKInvoiceSignature c_conv;
c_conv.inner = (void*)(c & (~1));
c_conv.is_owned = (c & 1) || (c == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(c_conv);
c_conv = InvoiceSignature_clone(&c_conv);
LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
*ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a_conv, b_ref, c_conv);
LDKPayeePubKey o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = PayeePubKey_clone(&o_conv);
LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
*ret_conv = CResult_PayeePubKeyErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PayeePubKeyErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_PayeePubKeyErrorZ* o_conv = (LDKCResult_PayeePubKeyErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PayeePubKeyErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PayeePubKeyErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PayeePubKeyErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
+ *ret_conv = CResult_PayeePubKeyErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PayeePubKeyErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_PayeePubKeyErrorZ* arg_conv = (LDKCResult_PayeePubKeyErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PayeePubKeyErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PayeePubKeyErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_PayeePubKeyErrorZ* orig_conv = (LDKCResult_PayeePubKeyErrorZ*)(orig & ~1);
LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
LDKPrivateRoute _res_conv_14_conv;
_res_conv_14_conv.inner = (void*)(_res_conv_14 & (~1));
_res_conv_14_conv.is_owned = (_res_conv_14 & 1) || (_res_conv_14 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_14_conv);
_res_constr.data[o] = _res_conv_14_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
LDKPositiveTimestamp o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = PositiveTimestamp_clone(&o_conv);
LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
*ret_conv = CResult_PositiveTimestampCreationErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PositiveTimestampCreationErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_PositiveTimestampCreationErrorZ* o_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PositiveTimestampCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PositiveTimestampCreationErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PositiveTimestampCreationErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
+ *ret_conv = CResult_PositiveTimestampCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PositiveTimestampCreationErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_PositiveTimestampCreationErrorZ* arg_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PositiveTimestampCreationErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_PositiveTimestampCreationErrorZ* orig_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)(orig & ~1);
LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NoneSemanticErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NoneSemanticErrorZ* o_conv = (LDKCResult_NoneSemanticErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneSemanticErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneSemanticErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneSemanticErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
+ *ret_conv = CResult_NoneSemanticErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneSemanticErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NoneSemanticErrorZ* arg_conv = (LDKCResult_NoneSemanticErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneSemanticErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneSemanticErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NoneSemanticErrorZ* orig_conv = (LDKCResult_NoneSemanticErrorZ*)(orig & ~1);
LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
LDKInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Invoice_clone(&o_conv);
LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
*ret_conv = CResult_InvoiceSemanticErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSemanticErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_InvoiceSemanticErrorZ* o_conv = (LDKCResult_InvoiceSemanticErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InvoiceSemanticErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSemanticErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_InvoiceSemanticErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg) {
+ LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
+ *ret_conv = CResult_InvoiceSemanticErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSemanticErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_InvoiceSemanticErrorZ* arg_conv = (LDKCResult_InvoiceSemanticErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_InvoiceSemanticErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSemanticErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_InvoiceSemanticErrorZ* orig_conv = (LDKCResult_InvoiceSemanticErrorZ*)(orig & ~1);
LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
LDKDescription o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Description_clone(&o_conv);
LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
*ret_conv = CResult_DescriptionCreationErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1DescriptionCreationErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_DescriptionCreationErrorZ* o_conv = (LDKCResult_DescriptionCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_DescriptionCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1DescriptionCreationErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_DescriptionCreationErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
+ *ret_conv = CResult_DescriptionCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DescriptionCreationErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_DescriptionCreationErrorZ* arg_conv = (LDKCResult_DescriptionCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_DescriptionCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DescriptionCreationErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_DescriptionCreationErrorZ* orig_conv = (LDKCResult_DescriptionCreationErrorZ*)(orig & ~1);
LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
LDKExpiryTime o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ExpiryTime_clone(&o_conv);
LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
*ret_conv = CResult_ExpiryTimeCreationErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ExpiryTimeCreationErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ExpiryTimeCreationErrorZ* o_conv = (LDKCResult_ExpiryTimeCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ExpiryTimeCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ExpiryTimeCreationErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ExpiryTimeCreationErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ExpiryTimeCreationErrorZ_clone_ptr(LDKCResult_ExpiryTimeCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
+ *ret_conv = CResult_ExpiryTimeCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ExpiryTimeCreationErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ExpiryTimeCreationErrorZ* arg_conv = (LDKCResult_ExpiryTimeCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ExpiryTimeCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ExpiryTimeCreationErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ExpiryTimeCreationErrorZ* orig_conv = (LDKCResult_ExpiryTimeCreationErrorZ*)(orig & ~1);
LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
LDKPrivateRoute o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = PrivateRoute_clone(&o_conv);
LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
*ret_conv = CResult_PrivateRouteCreationErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PrivateRouteCreationErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_PrivateRouteCreationErrorZ* o_conv = (LDKCResult_PrivateRouteCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PrivateRouteCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PrivateRouteCreationErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PrivateRouteCreationErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
+ *ret_conv = CResult_PrivateRouteCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PrivateRouteCreationErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_PrivateRouteCreationErrorZ* arg_conv = (LDKCResult_PrivateRouteCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PrivateRouteCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PrivateRouteCreationErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_PrivateRouteCreationErrorZ* orig_conv = (LDKCResult_PrivateRouteCreationErrorZ*)(orig & ~1);
LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1StringErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_StringErrorZ* o_conv = (LDKCResult_StringErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_StringErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1StringErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKChannelMonitorUpdate o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelMonitorUpdate_clone(&o_conv);
LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
*ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
*ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* o_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
+ *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* arg_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ChannelMonitorUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1MonitorEventZ_1some(JNIEnv *env, jclass clz, int64_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKMonitorEvent o_conv = *(LDKMonitorEvent*)(o_ptr);
+ o_conv = MonitorEvent_clone((LDKMonitorEvent*)(((uint64_t)o) & ~1));
+ LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
+ *ret_copy = COption_MonitorEventZ_some(o_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1MonitorEventZ_1none(JNIEnv *env, jclass clz) {
+ LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
+ *ret_copy = COption_MonitorEventZ_none();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1MonitorEventZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_MonitorEventZ _res_conv = *(LDKCOption_MonitorEventZ*)(_res_ptr);
+ FREE((void*)_res);
+ COption_MonitorEventZ_free(_res_conv);
+}
+
+static inline uint64_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg) {
+ LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
+ *ret_copy = COption_MonitorEventZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1MonitorEventZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCOption_MonitorEventZ* arg_conv = (LDKCOption_MonitorEventZ*)arg;
+ int64_t ret_val = COption_MonitorEventZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1MonitorEventZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+ LDKCOption_MonitorEventZ* orig_conv = (LDKCOption_MonitorEventZ*)orig;
+ LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
+ *ret_copy = COption_MonitorEventZ_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1MonitorEventZDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKCOption_MonitorEventZ o_conv = *(LDKCOption_MonitorEventZ*)(o_ptr);
+ o_conv = COption_MonitorEventZ_clone((LDKCOption_MonitorEventZ*)(((uint64_t)o) & ~1));
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1MonitorEventZDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1MonitorEventZDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* o_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1MonitorEventZDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_COption_MonitorEventZDecodeErrorZ _res_conv = *(LDKCResult_COption_MonitorEventZDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_COption_MonitorEventZDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1MonitorEventZDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* arg_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1MonitorEventZDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* orig_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(orig & ~1);
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCUpdateDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
LDKHTLCUpdate o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = HTLCUpdate_clone(&o_conv);
LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
*ret_conv = CResult_HTLCUpdateDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
*ret_conv = CResult_HTLCUpdateDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCUpdateDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_HTLCUpdateDecodeErrorZ* o_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_HTLCUpdateDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCUpdateDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_HTLCUpdateDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
+ *ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCUpdateDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_HTLCUpdateDecodeErrorZ* arg_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCUpdateDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_HTLCUpdateDecodeErrorZ* orig_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(orig & ~1);
LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
LDKMonitorUpdateError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = MonitorUpdateError_clone(&e_conv);
LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
*ret_conv = CResult_NoneMonitorUpdateErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NoneMonitorUpdateErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NoneMonitorUpdateErrorZ* o_conv = (LDKCResult_NoneMonitorUpdateErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneMonitorUpdateErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneMonitorUpdateErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneMonitorUpdateErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneMonitorUpdateErrorZ_clone_ptr(LDKCResult_NoneMonitorUpdateErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
+ *ret_conv = CResult_NoneMonitorUpdateErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneMonitorUpdateErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NoneMonitorUpdateErrorZ* arg_conv = (LDKCResult_NoneMonitorUpdateErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneMonitorUpdateErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneMonitorUpdateErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NoneMonitorUpdateErrorZ* orig_conv = (LDKCResult_NoneMonitorUpdateErrorZ*)(orig & ~1);
LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg) {
+ LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
+ *ret_conv = C2Tuple_OutPointScriptZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1OutPointScriptZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC2Tuple_OutPointScriptZ* arg_conv = (LDKC2Tuple_OutPointScriptZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_OutPointScriptZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1OutPointScriptZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC2Tuple_OutPointScriptZ* orig_conv = (LDKC2Tuple_OutPointScriptZ*)(orig & ~1);
LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
LDKOutPoint a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = OutPoint_clone(&a_conv);
LDKCVec_u8Z b_ref;
b_ref.datalen = (*env)->GetArrayLength(env, b);
C2Tuple_OutPointScriptZ_free(_res_conv);
}
+static inline uint64_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg) {
+ LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
+ *ret_conv = C2Tuple_u32ScriptZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32ScriptZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC2Tuple_u32ScriptZ* arg_conv = (LDKC2Tuple_u32ScriptZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_u32ScriptZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32ScriptZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC2Tuple_u32ScriptZ* orig_conv = (LDKC2Tuple_u32ScriptZ*)(orig & ~1);
LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
CVec_C2Tuple_u32ScriptZZ_free(_res_constr);
}
+static inline uint64_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg) {
+ LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
+ *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* arg_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(orig & ~1);
LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
CVec_TransactionZ_free(_res_constr);
}
+static inline uint64_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg) {
+ LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
+ *ret_conv = C2Tuple_u32TxOutZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32TxOutZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC2Tuple_u32TxOutZ* arg_conv = (LDKC2Tuple_u32TxOutZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_u32TxOutZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32TxOutZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC2Tuple_u32TxOutZ* orig_conv = (LDKC2Tuple_u32TxOutZ*)(orig & ~1);
LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
CVec_C2Tuple_u32TxOutZZ_free(_res_constr);
}
+static inline uint64_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg) {
+ LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
+ *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* arg_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(orig & ~1);
LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
*ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* o_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
+ *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* arg_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* orig_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(orig & ~1);
LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
LDKLightningError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = LightningError_clone(&e_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = CResult_NoneLightningErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NoneLightningErrorZ* o_conv = (LDKCResult_NoneLightningErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneLightningErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneLightningErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
+ *ret_conv = CResult_NoneLightningErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NoneLightningErrorZ* arg_conv = (LDKCResult_NoneLightningErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneLightningErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NoneLightningErrorZ* orig_conv = (LDKCResult_NoneLightningErrorZ*)(orig & ~1);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg) {
+ LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
+ *ret_conv = C2Tuple_PublicKeyTypeZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1PublicKeyTypeZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC2Tuple_PublicKeyTypeZ* arg_conv = (LDKC2Tuple_PublicKeyTypeZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_PublicKeyTypeZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1PublicKeyTypeZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC2Tuple_PublicKeyTypeZ* orig_conv = (LDKC2Tuple_PublicKeyTypeZ*)(orig & ~1);
LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
LDKLightningError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = LightningError_clone(&e_conv);
LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
*ret_conv = CResult_boolLightningErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_boolLightningErrorZ* o_conv = (LDKCResult_boolLightningErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_boolLightningErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_boolLightningErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg) {
+ LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
+ *ret_conv = CResult_boolLightningErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_boolLightningErrorZ* arg_conv = (LDKCResult_boolLightningErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_boolLightningErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_boolLightningErrorZ* orig_conv = (LDKCResult_boolLightningErrorZ*)(orig & ~1);
LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg) {
+ LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
+ *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* arg_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(arg & ~1);
+ int64_t ret_val = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* orig_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(orig & ~1);
LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
LDKChannelAnnouncement a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = ChannelAnnouncement_clone(&a_conv);
LDKChannelUpdate b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = (b & 1) || (b == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
b_conv = ChannelUpdate_clone(&b_conv);
LDKChannelUpdate c_conv;
c_conv.inner = (void*)(c & (~1));
c_conv.is_owned = (c & 1) || (c == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(c_conv);
c_conv = ChannelUpdate_clone(&c_conv);
LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
*ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a_conv, b_conv, c_conv);
LDKNodeAnnouncement _res_conv_18_conv;
_res_conv_18_conv.inner = (void*)(_res_conv_18 & (~1));
_res_conv_18_conv.is_owned = (_res_conv_18 & 1) || (_res_conv_18 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_18_conv);
_res_constr.data[s] = _res_conv_18_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
LDKPeerHandleError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = PeerHandleError_clone(&e_conv);
LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
*ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1u8ZPeerHandleErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_CVec_u8ZPeerHandleErrorZ* o_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1u8ZPeerHandleErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CVec_u8ZPeerHandleErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
+ *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1u8ZPeerHandleErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_CVec_u8ZPeerHandleErrorZ* arg_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1u8ZPeerHandleErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_CVec_u8ZPeerHandleErrorZ* orig_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(orig & ~1);
LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
LDKPeerHandleError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = PeerHandleError_clone(&e_conv);
LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
*ret_conv = CResult_NonePeerHandleErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NonePeerHandleErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NonePeerHandleErrorZ* o_conv = (LDKCResult_NonePeerHandleErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NonePeerHandleErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NonePeerHandleErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NonePeerHandleErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
+ *ret_conv = CResult_NonePeerHandleErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NonePeerHandleErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NonePeerHandleErrorZ* arg_conv = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NonePeerHandleErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NonePeerHandleErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NonePeerHandleErrorZ* orig_conv = (LDKCResult_NonePeerHandleErrorZ*)(orig & ~1);
LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
LDKPeerHandleError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = PeerHandleError_clone(&e_conv);
LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
*ret_conv = CResult_boolPeerHandleErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1boolPeerHandleErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_boolPeerHandleErrorZ* o_conv = (LDKCResult_boolPeerHandleErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_boolPeerHandleErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1boolPeerHandleErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_boolPeerHandleErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg) {
+ LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
+ *ret_conv = CResult_boolPeerHandleErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolPeerHandleErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_boolPeerHandleErrorZ* arg_conv = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_boolPeerHandleErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolPeerHandleErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_boolPeerHandleErrorZ* orig_conv = (LDKCResult_boolPeerHandleErrorZ*)(orig & ~1);
LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
LDKNodeId o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NodeId_clone(&o_conv);
LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
*ret_conv = CResult_NodeIdDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
*ret_conv = CResult_NodeIdDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NodeIdDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NodeIdDecodeErrorZ* o_conv = (LDKCResult_NodeIdDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeIdDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeIdDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NodeIdDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
+ *ret_conv = CResult_NodeIdDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeIdDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NodeIdDecodeErrorZ* arg_conv = (LDKCResult_NodeIdDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NodeIdDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeIdDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NodeIdDecodeErrorZ* orig_conv = (LDKCResult_NodeIdDecodeErrorZ*)(orig & ~1);
LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1NetworkUpdateZDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKCOption_NetworkUpdateZ o_conv = *(LDKCOption_NetworkUpdateZ*)(o_ptr);
+ o_conv = COption_NetworkUpdateZ_clone((LDKCOption_NetworkUpdateZ*)(((uint64_t)o) & ~1));
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1NetworkUpdateZDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1NetworkUpdateZDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* o_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1NetworkUpdateZDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res_conv = *(LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1NetworkUpdateZDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* arg_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1NetworkUpdateZDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* orig_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(orig & ~1);
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1AccessZ_1some(JNIEnv *env, jclass clz, int64_t o) {
void* o_ptr = (void*)(((uint64_t)o) & ~1);
CHECK_ACCESS(o_ptr);
LDKDirectionalChannelInfo o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = DirectionalChannelInfo_clone(&o_conv);
LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
*ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
*ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1DirectionalChannelInfoDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_DirectionalChannelInfoDecodeErrorZ* o_conv = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1DirectionalChannelInfoDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_DirectionalChannelInfoDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
+ *ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DirectionalChannelInfoDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_DirectionalChannelInfoDecodeErrorZ* arg_conv = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DirectionalChannelInfoDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_DirectionalChannelInfoDecodeErrorZ* orig_conv = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(orig & ~1);
LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
LDKChannelInfo o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelInfo_clone(&o_conv);
LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
*ret_conv = CResult_ChannelInfoDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
*ret_conv = CResult_ChannelInfoDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelInfoDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ChannelInfoDecodeErrorZ* o_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelInfoDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelInfoDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelInfoDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
+ *ret_conv = CResult_ChannelInfoDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelInfoDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ChannelInfoDecodeErrorZ* arg_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelInfoDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ChannelInfoDecodeErrorZ* orig_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
LDKRoutingFees o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RoutingFees_clone(&o_conv);
LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
*ret_conv = CResult_RoutingFeesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
*ret_conv = CResult_RoutingFeesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RoutingFeesDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_RoutingFeesDecodeErrorZ* o_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RoutingFeesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RoutingFeesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RoutingFeesDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
+ *ret_conv = CResult_RoutingFeesDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RoutingFeesDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_RoutingFeesDecodeErrorZ* arg_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RoutingFeesDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_RoutingFeesDecodeErrorZ* orig_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(orig & ~1);
LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
LDKNodeAnnouncementInfo o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NodeAnnouncementInfo_clone(&o_conv);
LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
*ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
*ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementInfoDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ* o_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementInfoDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
+ *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementInfoDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ* arg_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementInfoDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NodeAnnouncementInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(orig & ~1);
LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
LDKNodeInfo o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NodeInfo_clone(&o_conv);
LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
*ret_conv = CResult_NodeInfoDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
*ret_conv = CResult_NodeInfoDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NodeInfoDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NodeInfoDecodeErrorZ* o_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeInfoDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeInfoDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NodeInfoDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
+ *ret_conv = CResult_NodeInfoDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeInfoDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NodeInfoDecodeErrorZ* arg_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NodeInfoDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeInfoDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NodeInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(orig & ~1);
LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
LDKNetworkGraph o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NetworkGraph_clone(&o_conv);
LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
*ret_conv = CResult_NetworkGraphDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
*ret_conv = CResult_NetworkGraphDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NetworkGraphDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NetworkGraphDecodeErrorZ* o_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NetworkGraphDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NetworkGraphDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NetworkGraphDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NetworkGraphDecodeErrorZ_clone_ptr(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
+ *ret_conv = CResult_NetworkGraphDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetworkGraphDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NetworkGraphDecodeErrorZ* arg_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NetworkGraphDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetworkGraphDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NetworkGraphDecodeErrorZ* orig_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)(orig & ~1);
LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
COption_CVec_NetAddressZZ_free(_res_conv);
}
+static inline uint64_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg) {
+ LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
+ *ret_copy = COption_CVec_NetAddressZZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1CVec_1NetAddressZZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCOption_CVec_NetAddressZZ* arg_conv = (LDKCOption_CVec_NetAddressZZ*)arg;
+ int64_t ret_val = COption_CVec_NetAddressZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1CVec_1NetAddressZZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCOption_CVec_NetAddressZZ* orig_conv = (LDKCOption_CVec_NetAddressZZ*)orig;
LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
*ret_conv = CResult_NetAddressDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NetAddressDecodeErrorZ* o_conv = (LDKCResult_NetAddressDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NetAddressDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NetAddressDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
+ *ret_conv = CResult_NetAddressDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NetAddressDecodeErrorZ* arg_conv = (LDKCResult_NetAddressDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NetAddressDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NetAddressDecodeErrorZ* orig_conv = (LDKCResult_NetAddressDecodeErrorZ*)(orig & ~1);
LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
LDKUpdateAddHTLC _res_conv_15_conv;
_res_conv_15_conv.inner = (void*)(_res_conv_15 & (~1));
_res_conv_15_conv.is_owned = (_res_conv_15 & 1) || (_res_conv_15 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_15_conv);
_res_constr.data[p] = _res_conv_15_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
LDKUpdateFulfillHTLC _res_conv_19_conv;
_res_conv_19_conv.inner = (void*)(_res_conv_19 & (~1));
_res_conv_19_conv.is_owned = (_res_conv_19 & 1) || (_res_conv_19 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_19_conv);
_res_constr.data[t] = _res_conv_19_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
LDKUpdateFailHTLC _res_conv_16_conv;
_res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
_res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
_res_constr.data[q] = _res_conv_16_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
LDKUpdateFailMalformedHTLC _res_conv_25_conv;
_res_conv_25_conv.inner = (void*)(_res_conv_25 & (~1));
_res_conv_25_conv.is_owned = (_res_conv_25 & 1) || (_res_conv_25 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_25_conv);
_res_constr.data[z] = _res_conv_25_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
LDKAcceptChannel o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = AcceptChannel_clone(&o_conv);
LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
*ret_conv = CResult_AcceptChannelDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
*ret_conv = CResult_AcceptChannelDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1AcceptChannelDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_AcceptChannelDecodeErrorZ* o_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_AcceptChannelDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1AcceptChannelDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_AcceptChannelDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
+ *ret_conv = CResult_AcceptChannelDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1AcceptChannelDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_AcceptChannelDecodeErrorZ* arg_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1AcceptChannelDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_AcceptChannelDecodeErrorZ* orig_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(orig & ~1);
LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
LDKAnnouncementSignatures o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = AnnouncementSignatures_clone(&o_conv);
LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
*ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
*ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1AnnouncementSignaturesDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ* o_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1AnnouncementSignaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_AnnouncementSignaturesDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
+ *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1AnnouncementSignaturesDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ* arg_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1AnnouncementSignaturesDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_AnnouncementSignaturesDecodeErrorZ* orig_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(orig & ~1);
LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
LDKChannelReestablish o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelReestablish_clone(&o_conv);
LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
*ret_conv = CResult_ChannelReestablishDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
*ret_conv = CResult_ChannelReestablishDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelReestablishDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ChannelReestablishDecodeErrorZ* o_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelReestablishDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelReestablishDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelReestablishDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
+ *ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelReestablishDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ChannelReestablishDecodeErrorZ* arg_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelReestablishDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ChannelReestablishDecodeErrorZ* orig_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
LDKClosingSigned o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ClosingSigned_clone(&o_conv);
LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
*ret_conv = CResult_ClosingSignedDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
*ret_conv = CResult_ClosingSignedDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ClosingSignedDecodeErrorZ* o_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ClosingSignedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ClosingSignedDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
+ *ret_conv = CResult_ClosingSignedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ClosingSignedDecodeErrorZ* arg_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ClosingSignedDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(orig & ~1);
LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
LDKClosingSignedFeeRange o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ClosingSignedFeeRange_clone(&o_conv);
LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
*ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
*ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedFeeRangeDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* o_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedFeeRangeDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
+ *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedFeeRangeDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* arg_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedFeeRangeDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(orig & ~1);
LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
LDKCommitmentSigned o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = CommitmentSigned_clone(&o_conv);
LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
*ret_conv = CResult_CommitmentSignedDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
*ret_conv = CResult_CommitmentSignedDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentSignedDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_CommitmentSignedDecodeErrorZ* o_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CommitmentSignedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentSignedDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CommitmentSignedDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
+ *ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentSignedDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_CommitmentSignedDecodeErrorZ* arg_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentSignedDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_CommitmentSignedDecodeErrorZ* orig_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(orig & ~1);
LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
LDKFundingCreated o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = FundingCreated_clone(&o_conv);
LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
*ret_conv = CResult_FundingCreatedDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
*ret_conv = CResult_FundingCreatedDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1FundingCreatedDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_FundingCreatedDecodeErrorZ* o_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_FundingCreatedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1FundingCreatedDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_FundingCreatedDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
+ *ret_conv = CResult_FundingCreatedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingCreatedDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_FundingCreatedDecodeErrorZ* arg_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingCreatedDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_FundingCreatedDecodeErrorZ* orig_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(orig & ~1);
LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
LDKFundingSigned o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = FundingSigned_clone(&o_conv);
LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
*ret_conv = CResult_FundingSignedDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
*ret_conv = CResult_FundingSignedDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1FundingSignedDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_FundingSignedDecodeErrorZ* o_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_FundingSignedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1FundingSignedDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_FundingSignedDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
+ *ret_conv = CResult_FundingSignedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingSignedDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_FundingSignedDecodeErrorZ* arg_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_FundingSignedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingSignedDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_FundingSignedDecodeErrorZ* orig_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(orig & ~1);
LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
LDKFundingLocked o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = FundingLocked_clone(&o_conv);
LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
*ret_conv = CResult_FundingLockedDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
*ret_conv = CResult_FundingLockedDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1FundingLockedDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_FundingLockedDecodeErrorZ* o_conv = (LDKCResult_FundingLockedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_FundingLockedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1FundingLockedDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_FundingLockedDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_FundingLockedDecodeErrorZ_clone_ptr(LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
+ *ret_conv = CResult_FundingLockedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingLockedDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_FundingLockedDecodeErrorZ* arg_conv = (LDKCResult_FundingLockedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_FundingLockedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingLockedDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_FundingLockedDecodeErrorZ* orig_conv = (LDKCResult_FundingLockedDecodeErrorZ*)(orig & ~1);
LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
LDKInit o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Init_clone(&o_conv);
LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
*ret_conv = CResult_InitDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
*ret_conv = CResult_InitDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1InitDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_InitDecodeErrorZ* o_conv = (LDKCResult_InitDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InitDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InitDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_InitDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
+ *ret_conv = CResult_InitDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InitDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_InitDecodeErrorZ* arg_conv = (LDKCResult_InitDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_InitDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InitDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_InitDecodeErrorZ* orig_conv = (LDKCResult_InitDecodeErrorZ*)(orig & ~1);
LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
LDKOpenChannel o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = OpenChannel_clone(&o_conv);
LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
*ret_conv = CResult_OpenChannelDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
*ret_conv = CResult_OpenChannelDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1OpenChannelDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_OpenChannelDecodeErrorZ* o_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_OpenChannelDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1OpenChannelDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_OpenChannelDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
+ *ret_conv = CResult_OpenChannelDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OpenChannelDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_OpenChannelDecodeErrorZ* arg_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_OpenChannelDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OpenChannelDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_OpenChannelDecodeErrorZ* orig_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(orig & ~1);
LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
LDKRevokeAndACK o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RevokeAndACK_clone(&o_conv);
LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
*ret_conv = CResult_RevokeAndACKDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
*ret_conv = CResult_RevokeAndACKDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RevokeAndACKDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_RevokeAndACKDecodeErrorZ* o_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RevokeAndACKDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RevokeAndACKDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RevokeAndACKDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
+ *ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RevokeAndACKDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_RevokeAndACKDecodeErrorZ* arg_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RevokeAndACKDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_RevokeAndACKDecodeErrorZ* orig_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(orig & ~1);
LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
LDKShutdown o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Shutdown_clone(&o_conv);
LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
*ret_conv = CResult_ShutdownDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
*ret_conv = CResult_ShutdownDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ShutdownDecodeErrorZ* o_conv = (LDKCResult_ShutdownDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ShutdownDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ShutdownDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
+ *ret_conv = CResult_ShutdownDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ShutdownDecodeErrorZ* arg_conv = (LDKCResult_ShutdownDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ShutdownDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ShutdownDecodeErrorZ* orig_conv = (LDKCResult_ShutdownDecodeErrorZ*)(orig & ~1);
LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
LDKUpdateFailHTLC o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UpdateFailHTLC_clone(&o_conv);
LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailHTLCDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_UpdateFailHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailHTLCDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UpdateFailHTLCDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailHTLCDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_UpdateFailHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailHTLCDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_UpdateFailHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(orig & ~1);
LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
LDKUpdateFailMalformedHTLC o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UpdateFailMalformedHTLC_clone(&o_conv);
LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailMalformedHTLCDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailMalformedHTLCDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailMalformedHTLCDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailMalformedHTLCDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(orig & ~1);
LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
LDKUpdateFee o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UpdateFee_clone(&o_conv);
LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
*ret_conv = CResult_UpdateFeeDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
*ret_conv = CResult_UpdateFeeDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFeeDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_UpdateFeeDecodeErrorZ* o_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateFeeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFeeDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UpdateFeeDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
+ *ret_conv = CResult_UpdateFeeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFeeDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_UpdateFeeDecodeErrorZ* arg_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFeeDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_UpdateFeeDecodeErrorZ* orig_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(orig & ~1);
LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
LDKUpdateFulfillHTLC o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UpdateFulfillHTLC_clone(&o_conv);
LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFulfillHTLCDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFulfillHTLCDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFulfillHTLCDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFulfillHTLCDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_UpdateFulfillHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(orig & ~1);
LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
LDKUpdateAddHTLC o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UpdateAddHTLC_clone(&o_conv);
LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateAddHTLCDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_UpdateAddHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateAddHTLCDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UpdateAddHTLCDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateAddHTLCDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_UpdateAddHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateAddHTLCDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_UpdateAddHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(orig & ~1);
LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
LDKPing o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Ping_clone(&o_conv);
LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
*ret_conv = CResult_PingDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
*ret_conv = CResult_PingDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PingDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_PingDecodeErrorZ* o_conv = (LDKCResult_PingDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PingDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PingDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PingDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
+ *ret_conv = CResult_PingDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PingDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_PingDecodeErrorZ* arg_conv = (LDKCResult_PingDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PingDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PingDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_PingDecodeErrorZ* orig_conv = (LDKCResult_PingDecodeErrorZ*)(orig & ~1);
LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
LDKPong o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Pong_clone(&o_conv);
LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
*ret_conv = CResult_PongDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
*ret_conv = CResult_PongDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PongDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_PongDecodeErrorZ* o_conv = (LDKCResult_PongDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PongDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PongDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PongDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
+ *ret_conv = CResult_PongDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PongDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_PongDecodeErrorZ* arg_conv = (LDKCResult_PongDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PongDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PongDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_PongDecodeErrorZ* orig_conv = (LDKCResult_PongDecodeErrorZ*)(orig & ~1);
LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
LDKUnsignedChannelAnnouncement o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UnsignedChannelAnnouncement_clone(&o_conv);
LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
*ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
*ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelAnnouncementDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* o_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelAnnouncementDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelAnnouncementDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelAnnouncementDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(orig & ~1);
LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
LDKChannelAnnouncement o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelAnnouncement_clone(&o_conv);
LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
*ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
*ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelAnnouncementDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ChannelAnnouncementDecodeErrorZ* o_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelAnnouncementDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelAnnouncementDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelAnnouncementDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ChannelAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelAnnouncementDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
LDKUnsignedChannelUpdate o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UnsignedChannelUpdate_clone(&o_conv);
LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
*ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
*ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelUpdateDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ* o_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelUpdateDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
+ *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelUpdateDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ* arg_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelUpdateDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_UnsignedChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(orig & ~1);
LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
LDKChannelUpdate o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelUpdate_clone(&o_conv);
LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
*ret_conv = CResult_ChannelUpdateDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
*ret_conv = CResult_ChannelUpdateDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelUpdateDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ChannelUpdateDecodeErrorZ* o_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelUpdateDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelUpdateDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelUpdateDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
+ *ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelUpdateDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ChannelUpdateDecodeErrorZ* arg_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelUpdateDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
LDKErrorMessage o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ErrorMessage_clone(&o_conv);
LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
*ret_conv = CResult_ErrorMessageDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
*ret_conv = CResult_ErrorMessageDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ErrorMessageDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ErrorMessageDecodeErrorZ* o_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ErrorMessageDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ErrorMessageDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ErrorMessageDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
+ *ret_conv = CResult_ErrorMessageDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ErrorMessageDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ErrorMessageDecodeErrorZ* arg_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ErrorMessageDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ErrorMessageDecodeErrorZ* orig_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(orig & ~1);
LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
LDKUnsignedNodeAnnouncement o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UnsignedNodeAnnouncement_clone(&o_conv);
LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
*ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
*ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedNodeAnnouncementDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* o_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedNodeAnnouncementDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedNodeAnnouncementDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedNodeAnnouncementDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(orig & ~1);
LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
LDKNodeAnnouncement o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NodeAnnouncement_clone(&o_conv);
LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
*ret_conv = CResult_NodeAnnouncementDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
*ret_conv = CResult_NodeAnnouncementDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NodeAnnouncementDecodeErrorZ* o_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeAnnouncementDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NodeAnnouncementDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NodeAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(orig & ~1);
LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
LDKQueryShortChannelIds o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = QueryShortChannelIds_clone(&o_conv);
LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
*ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
*ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1QueryShortChannelIdsDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ* o_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1QueryShortChannelIdsDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_QueryShortChannelIdsDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
+ *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1QueryShortChannelIdsDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ* arg_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1QueryShortChannelIdsDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_QueryShortChannelIdsDecodeErrorZ* orig_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(orig & ~1);
LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
LDKReplyShortChannelIdsEnd o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ReplyShortChannelIdsEnd_clone(&o_conv);
LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
*ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
*ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyShortChannelIdsEndDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* o_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyShortChannelIdsEndDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
+ *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyShortChannelIdsEndDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* arg_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyShortChannelIdsEndDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* orig_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(orig & ~1);
LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
LDKQueryChannelRange o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = QueryChannelRange_clone(&o_conv);
LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
*ret_conv = CResult_QueryChannelRangeDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
*ret_conv = CResult_QueryChannelRangeDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1QueryChannelRangeDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_QueryChannelRangeDecodeErrorZ* o_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_QueryChannelRangeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1QueryChannelRangeDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_QueryChannelRangeDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
+ *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1QueryChannelRangeDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_QueryChannelRangeDecodeErrorZ* arg_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1QueryChannelRangeDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_QueryChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(orig & ~1);
LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
LDKReplyChannelRange o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ReplyChannelRange_clone(&o_conv);
LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
*ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
*ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyChannelRangeDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ReplyChannelRangeDecodeErrorZ* o_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyChannelRangeDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ReplyChannelRangeDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
+ *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyChannelRangeDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ReplyChannelRangeDecodeErrorZ* arg_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyChannelRangeDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ReplyChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(orig & ~1);
LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
LDKGossipTimestampFilter o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = GossipTimestampFilter_clone(&o_conv);
LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
*ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
*ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1GossipTimestampFilterDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_GossipTimestampFilterDecodeErrorZ* o_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1GossipTimestampFilterDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_GossipTimestampFilterDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
+ *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1GossipTimestampFilterDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_GossipTimestampFilterDecodeErrorZ* arg_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1GossipTimestampFilterDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_GossipTimestampFilterDecodeErrorZ* orig_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(orig & ~1);
LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
LDKInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Invoice_clone(&o_conv);
LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
*ret_conv = CResult_InvoiceSignOrCreationErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSignOrCreationErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_InvoiceSignOrCreationErrorZ* o_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InvoiceSignOrCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSignOrCreationErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_InvoiceSignOrCreationErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
+ *ret_conv = CResult_InvoiceSignOrCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSignOrCreationErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_InvoiceSignOrCreationErrorZ* arg_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSignOrCreationErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_InvoiceSignOrCreationErrorZ* orig_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)(orig & ~1);
LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
LDKLockedChannelMonitor o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
// Warning: we need a move here but no clone is available for LDKLockedChannelMonitor
LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
*ret_conv = CResult_LockedChannelMonitorNoneZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1LockedChannelMonitorNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_LockedChannelMonitorNoneZ* o_conv = (LDKCResult_LockedChannelMonitorNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_LockedChannelMonitorNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1LockedChannelMonitorNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKOutPoint _res_conv_10_conv;
_res_conv_10_conv.inner = (void*)(_res_conv_10 & (~1));
_res_conv_10_conv.is_owned = (_res_conv_10 & 1) || (_res_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_10_conv);
_res_constr.data[k] = _res_conv_10_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
PaymentPurpose_free(this_ptr_conv);
}
+static inline uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg) {
+ LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
+ *ret_copy = PaymentPurpose_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PaymentPurpose_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKPaymentPurpose* arg_conv = (LDKPaymentPurpose*)arg;
+ int64_t ret_val = PaymentPurpose_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PaymentPurpose_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKPaymentPurpose* orig_conv = (LDKPaymentPurpose*)orig;
LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
ClosureReason_free(this_ptr_conv);
}
+static inline uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg) {
+ LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
+ *ret_copy = ClosureReason_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosureReason_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKClosureReason* arg_conv = (LDKClosureReason*)arg;
+ int64_t ret_val = ClosureReason_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosureReason_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKClosureReason* orig_conv = (LDKClosureReason*)orig;
LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
return ret_arr;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosureReason_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = (*env)->GetArrayLength(env, ser);
+ ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = ClosureReason_read(ser_ref);
+ (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
+ return (uint64_t)ret_conv;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Event_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
if ((this_ptr & 1) != 0) return;
void* this_ptr_ptr = (void*)(((uint64_t)this_ptr) & ~1);
Event_free(this_ptr_conv);
}
+static inline uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg) {
+ LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
+ *ret_copy = Event_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Event_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKEvent* arg_conv = (LDKEvent*)arg;
+ int64_t ret_val = Event_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Event_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKEvent* orig_conv = (LDKEvent*)orig;
LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
LDKRouteHop path_conv_10_conv;
path_conv_10_conv.inner = (void*)(path_conv_10 & (~1));
path_conv_10_conv.is_owned = (path_conv_10 & 1) || (path_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
path_constr.data[k] = path_conv_10_conv;
}
LDKRouteParameters retry_conv;
retry_conv.inner = (void*)(retry & (~1));
retry_conv.is_owned = (retry & 1) || (retry == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(retry_conv);
retry_conv = RouteParameters_clone(&retry_conv);
LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
*ret_copy = Event_payment_path_failed(payment_id_ref, payment_hash_ref, rejected_by_dest, network_update_conv, all_paths_failed, path_constr, short_channel_id_conv, retry_conv);
return ret_arr;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Event_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = (*env)->GetArrayLength(env, ser);
+ ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = Event_read(ser_ref);
+ (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
+ return (uint64_t)ret_conv;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MessageSendEvent_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
if ((this_ptr & 1) != 0) return;
void* this_ptr_ptr = (void*)(((uint64_t)this_ptr) & ~1);
MessageSendEvent_free(this_ptr_conv);
}
+static inline uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg) {
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MessageSendEvent_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKMessageSendEvent* arg_conv = (LDKMessageSendEvent*)arg;
+ int64_t ret_val = MessageSendEvent_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MessageSendEvent_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKMessageSendEvent* orig_conv = (LDKMessageSendEvent*)orig;
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
LDKAcceptChannel msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = AcceptChannel_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_accept_channel(node_id_ref, msg_conv);
LDKOpenChannel msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = OpenChannel_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_open_channel(node_id_ref, msg_conv);
LDKFundingCreated msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = FundingCreated_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_funding_created(node_id_ref, msg_conv);
LDKFundingSigned msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = FundingSigned_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_funding_signed(node_id_ref, msg_conv);
LDKFundingLocked msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = FundingLocked_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_funding_locked(node_id_ref, msg_conv);
LDKAnnouncementSignatures msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = AnnouncementSignatures_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_announcement_signatures(node_id_ref, msg_conv);
LDKCommitmentUpdate updates_conv;
updates_conv.inner = (void*)(updates & (~1));
updates_conv.is_owned = (updates & 1) || (updates == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_conv);
updates_conv = CommitmentUpdate_clone(&updates_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_update_htlcs(node_id_ref, updates_conv);
LDKRevokeAndACK msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = RevokeAndACK_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_revoke_and_ack(node_id_ref, msg_conv);
LDKClosingSigned msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ClosingSigned_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_closing_signed(node_id_ref, msg_conv);
LDKShutdown msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = Shutdown_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_shutdown(node_id_ref, msg_conv);
LDKChannelReestablish msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ChannelReestablish_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_channel_reestablish(node_id_ref, msg_conv);
LDKChannelAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ChannelAnnouncement_clone(&msg_conv);
LDKChannelUpdate update_msg_conv;
update_msg_conv.inner = (void*)(update_msg & (~1));
update_msg_conv.is_owned = (update_msg & 1) || (update_msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_conv);
update_msg_conv = ChannelUpdate_clone(&update_msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_broadcast_channel_announcement(msg_conv, update_msg_conv);
LDKNodeAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = NodeAnnouncement_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_broadcast_node_announcement(msg_conv);
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ChannelUpdate_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_broadcast_channel_update(msg_conv);
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ChannelUpdate_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_channel_update(node_id_ref, msg_conv);
LDKQueryChannelRange msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = QueryChannelRange_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_channel_range_query(node_id_ref, msg_conv);
LDKQueryShortChannelIds msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = QueryShortChannelIds_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_short_ids_query(node_id_ref, msg_conv);
LDKReplyChannelRange msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ReplyChannelRange_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_reply_channel_range(node_id_ref, msg_conv);
APIError_free(this_ptr_conv);
}
+static inline uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg) {
+ LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
+ *ret_copy = APIError_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_APIError_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKAPIError* arg_conv = (LDKAPIError*)arg;
+ int64_t ret_val = APIError_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_APIError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKAPIError* orig_conv = (LDKAPIError*)orig;
LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
LDKShutdownScript script_conv;
script_conv.inner = (void*)(script & (~1));
script_conv.is_owned = (script & 1) || (script == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(script_conv);
script_conv = ShutdownScript_clone(&script_conv);
LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
*ret_copy = APIError_incompatible_shutdown_script(script_conv);
return ret_conv;
}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Record_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
+ LDKRecord this_obj_conv;
+ this_obj_conv.inner = (void*)(this_obj & (~1));
+ this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
+ Record_free(this_obj_conv);
+}
+
+JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_Record_1get_1level(JNIEnv *env, jclass clz, int64_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ jclass ret_conv = LDKLevel_to_java(env, Record_get_level(&this_ptr_conv));
+ return ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Record_1set_1level(JNIEnv *env, jclass clz, int64_t this_ptr, jclass val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKLevel val_conv = LDKLevel_from_java(env, val);
+ Record_set_level(&this_ptr_conv, val_conv);
+}
+
+JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_Record_1get_1args(JNIEnv *env, jclass clz, int64_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr ret_str = Record_get_args(&this_ptr_conv);
+ jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
+ Str_free(ret_str);
+ return ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Record_1set_1args(JNIEnv *env, jclass clz, int64_t this_ptr, jstring val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr val_conv = java_to_owned_str(env, val);
+ Record_set_args(&this_ptr_conv, val_conv);
+}
+
+JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_Record_1get_1module_1path(JNIEnv *env, jclass clz, int64_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr ret_str = Record_get_module_path(&this_ptr_conv);
+ jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
+ Str_free(ret_str);
+ return ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Record_1set_1module_1path(JNIEnv *env, jclass clz, int64_t this_ptr, jstring val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr val_conv = java_to_owned_str(env, val);
+ Record_set_module_path(&this_ptr_conv, val_conv);
+}
+
+JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_Record_1get_1file(JNIEnv *env, jclass clz, int64_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr ret_str = Record_get_file(&this_ptr_conv);
+ jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
+ Str_free(ret_str);
+ return ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Record_1set_1file(JNIEnv *env, jclass clz, int64_t this_ptr, jstring val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr val_conv = java_to_owned_str(env, val);
+ Record_set_file(&this_ptr_conv, val_conv);
+}
+
+JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_Record_1get_1line(JNIEnv *env, jclass clz, int64_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ int32_t ret_val = Record_get_line(&this_ptr_conv);
+ return ret_val;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Record_1set_1line(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ Record_set_line(&this_ptr_conv, val);
+}
+
+static inline uint64_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg) {
+ LDKRecord ret_var = Record_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Record_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKRecord arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Record_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Record_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+ LDKRecord orig_conv;
+ orig_conv.inner = (void*)(orig & (~1));
+ orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
+ LDKRecord ret_var = Record_clone(&orig_conv);
+ uint64_t ret_ref = 0;
+ CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = (uint64_t)ret_var.inner;
+ if (ret_var.is_owned) {
+ ret_ref |= 1;
+ }
+ return ret_ref;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Logger_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
if ((this_ptr & 1) != 0) return;
void* this_ptr_ptr = (void*)(((uint64_t)this_ptr) & ~1);
LDKChannelHandshakeConfig this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelHandshakeConfig_free(this_obj_conv);
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ChannelHandshakeConfig_get_minimum_depth(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeConfig_set_minimum_depth(&this_ptr_conv, val);
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = ChannelHandshakeConfig_get_our_to_self_delay(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeConfig_set_our_to_self_delay(&this_ptr_conv, val);
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelHandshakeConfig_get_our_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeConfig_set_our_htlc_minimum_msat(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg) {
+ LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelHandshakeConfig arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelHandshakeConfig_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelHandshakeConfig orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelHandshakeLimits this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelHandshakeLimits_free(this_obj_conv);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelHandshakeLimits_get_min_funding_satoshis(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_min_funding_satoshis(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelHandshakeLimits_get_max_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_max_htlc_minimum_msat(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelHandshakeLimits_get_max_channel_reserve_satoshis(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_max_channel_reserve_satoshis(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = ChannelHandshakeLimits_get_min_max_accepted_htlcs(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_min_max_accepted_htlcs(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ChannelHandshakeLimits_get_max_minimum_depth(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_max_minimum_depth(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelHandshakeLimits_get_force_announced_channel_preference(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_force_announced_channel_preference(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = ChannelHandshakeLimits_get_their_to_self_delay(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_their_to_self_delay(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg) {
+ LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelHandshakeLimits arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelHandshakeLimits_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelHandshakeLimits orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelConfig this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelConfig_free(this_obj_conv);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ChannelConfig_get_forwarding_fee_proportional_millionths(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_forwarding_fee_proportional_millionths(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ChannelConfig_get_forwarding_fee_base_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_forwarding_fee_base_msat(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = ChannelConfig_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelConfig_get_announced_channel(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_announced_channel(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelConfig_get_commit_upfront_shutdown_pubkey(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_commit_upfront_shutdown_pubkey(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelConfig_get_max_dust_htlc_exposure_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_max_dust_htlc_exposure_msat(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelConfig_get_force_close_avoidance_max_fee_satoshis(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_force_close_avoidance_max_fee_satoshis(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg) {
+ LDKChannelConfig ret_var = ChannelConfig_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelConfig arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelConfig_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelConfig orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelConfig ret_var = ChannelConfig_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelConfig obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelConfig_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKUserConfig this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UserConfig_free(this_obj_conv);
}
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelHandshakeConfig ret_var = UserConfig_get_own_channel_config(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelHandshakeConfig val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelHandshakeConfig_clone(&val_conv);
UserConfig_set_own_channel_config(&this_ptr_conv, val_conv);
}
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelHandshakeLimits ret_var = UserConfig_get_peer_channel_config_limits(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelHandshakeLimits val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelHandshakeLimits_clone(&val_conv);
UserConfig_set_peer_channel_config_limits(&this_ptr_conv, val_conv);
}
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelConfig ret_var = UserConfig_get_channel_options(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelConfig val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelConfig_clone(&val_conv);
UserConfig_set_channel_options(&this_ptr_conv, val_conv);
}
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = UserConfig_get_accept_forwards_to_priv_channels(&this_ptr_conv);
return ret_val;
}
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UserConfig_set_accept_forwards_to_priv_channels(&this_ptr_conv, val);
}
LDKChannelHandshakeConfig own_channel_config_arg_conv;
own_channel_config_arg_conv.inner = (void*)(own_channel_config_arg & (~1));
own_channel_config_arg_conv.is_owned = (own_channel_config_arg & 1) || (own_channel_config_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(own_channel_config_arg_conv);
own_channel_config_arg_conv = ChannelHandshakeConfig_clone(&own_channel_config_arg_conv);
LDKChannelHandshakeLimits peer_channel_config_limits_arg_conv;
peer_channel_config_limits_arg_conv.inner = (void*)(peer_channel_config_limits_arg & (~1));
peer_channel_config_limits_arg_conv.is_owned = (peer_channel_config_limits_arg & 1) || (peer_channel_config_limits_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(peer_channel_config_limits_arg_conv);
peer_channel_config_limits_arg_conv = ChannelHandshakeLimits_clone(&peer_channel_config_limits_arg_conv);
LDKChannelConfig channel_options_arg_conv;
channel_options_arg_conv.inner = (void*)(channel_options_arg & (~1));
channel_options_arg_conv.is_owned = (channel_options_arg & 1) || (channel_options_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_options_arg_conv);
channel_options_arg_conv = ChannelConfig_clone(&channel_options_arg_conv);
LDKUserConfig ret_var = UserConfig_new(own_channel_config_arg_conv, peer_channel_config_limits_arg_conv, channel_options_arg_conv, accept_forwards_to_priv_channels_arg);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg) {
+ LDKUserConfig ret_var = UserConfig_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UserConfig_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKUserConfig arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UserConfig_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UserConfig_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKUserConfig orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUserConfig ret_var = UserConfig_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKBestBlock this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
BestBlock_free(this_obj_conv);
}
+static inline uint64_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg) {
+ LDKBestBlock ret_var = BestBlock_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BestBlock_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKBestBlock arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = BestBlock_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BestBlock_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKBestBlock orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKBestBlock ret_var = BestBlock_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKBestBlock this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, BestBlock_block_hash(&this_arg_conv).data);
return ret_arr;
LDKBestBlock this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int32_t ret_val = BestBlock_height(&this_arg_conv);
return ret_val;
}
LDKWatchedOutput this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
WatchedOutput_free(this_obj_conv);
}
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, WatchedOutput_get_block_hash(&this_ptr_conv).data);
return ret_arr;
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint ret_var = WatchedOutput_get_outpoint(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = OutPoint_clone(&val_conv);
WatchedOutput_set_outpoint(&this_ptr_conv, val_conv);
}
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKu8slice ret_var = WatchedOutput_get_script_pubkey(&this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u8Z val_ref;
val_ref.datalen = (*env)->GetArrayLength(env, val);
val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
LDKOutPoint outpoint_arg_conv;
outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
LDKCVec_u8Z script_pubkey_arg_ref;
script_pubkey_arg_ref.datalen = (*env)->GetArrayLength(env, script_pubkey_arg);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg) {
+ LDKWatchedOutput ret_var = WatchedOutput_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_WatchedOutput_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKWatchedOutput arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = WatchedOutput_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_WatchedOutput_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKWatchedOutput orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKWatchedOutput ret_var = WatchedOutput_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKWatchedOutput o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = WatchedOutput_hash(&o_conv);
return ret_val;
}
LDKMonitorUpdateId this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
MonitorUpdateId_free(this_obj_conv);
}
+static inline uint64_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg) {
+ LDKMonitorUpdateId ret_var = MonitorUpdateId_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MonitorUpdateId_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKMonitorUpdateId arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = MonitorUpdateId_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MonitorUpdateId_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKMonitorUpdateId orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKMonitorUpdateId ret_var = MonitorUpdateId_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKMonitorUpdateId o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = MonitorUpdateId_hash(&o_conv);
return ret_val;
}
LDKMonitorUpdateId a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKMonitorUpdateId b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = MonitorUpdateId_eq(&a_conv, &b_conv);
return ret_val;
}
LDKLockedChannelMonitor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
LockedChannelMonitor_free(this_obj_conv);
}
LDKChainMonitor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChainMonitor_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_ChannelDetailsZ ignored_channels_constr;
ignored_channels_constr.datalen = (*env)->GetArrayLength(env, ignored_channels);
if (ignored_channels_constr.datalen > 0)
LDKChannelDetails ignored_channels_conv_16_conv;
ignored_channels_conv_16_conv.inner = (void*)(ignored_channels_conv_16 & (~1));
ignored_channels_conv_16_conv.is_owned = (ignored_channels_conv_16 & 1) || (ignored_channels_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ignored_channels_conv_16_conv);
ignored_channels_conv_16_conv = ChannelDetails_clone(&ignored_channels_conv_16_conv);
ignored_channels_constr.data[q] = ignored_channels_conv_16_conv;
}
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKOutPoint funding_txo_conv;
funding_txo_conv.inner = (void*)(funding_txo & (~1));
funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
funding_txo_conv = OutPoint_clone(&funding_txo_conv);
LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
*ret_conv = ChainMonitor_get_monitor(&this_arg_conv, funding_txo_conv);
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_OutPointZ ret_var = ChainMonitor_list_monitors(&this_arg_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_10_ref = 0;
CHECK((((uint64_t)ret_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_10_var);
ret_conv_10_ref = (uint64_t)ret_conv_10_var.inner;
if (ret_conv_10_var.is_owned) {
ret_conv_10_ref |= 1;
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKOutPoint funding_txo_conv;
funding_txo_conv.inner = (void*)(funding_txo & (~1));
funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
funding_txo_conv = OutPoint_clone(&funding_txo_conv);
LDKMonitorUpdateId completed_update_id_conv;
completed_update_id_conv.inner = (void*)(completed_update_id & (~1));
completed_update_id_conv.is_owned = (completed_update_id & 1) || (completed_update_id == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(completed_update_id_conv);
completed_update_id_conv = MonitorUpdateId_clone(&completed_update_id_conv);
LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
*ret_conv = ChainMonitor_channel_monitor_updated(&this_arg_conv, funding_txo_conv, completed_update_id_conv);
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKListen* ret_ret = MALLOC(sizeof(LDKListen), "LDKListen");
*ret_ret = ChainMonitor_as_Listen(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKConfirm* ret_ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
*ret_ret = ChainMonitor_as_Confirm(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKWatch* ret_ret = MALLOC(sizeof(LDKWatch), "LDKWatch");
*ret_ret = ChainMonitor_as_Watch(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKEventsProvider* ret_ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
*ret_ret = ChainMonitor_as_EventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelMonitorUpdate this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelMonitorUpdate_free(this_obj_conv);
}
LDKChannelMonitorUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelMonitorUpdate_get_update_id(&this_ptr_conv);
return ret_val;
}
LDKChannelMonitorUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelMonitorUpdate_set_update_id(&this_ptr_conv, val);
}
+static inline uint64_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg) {
+ LDKChannelMonitorUpdate ret_var = ChannelMonitorUpdate_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMonitorUpdate_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelMonitorUpdate arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelMonitorUpdate_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMonitorUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelMonitorUpdate orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelMonitorUpdate ret_var = ChannelMonitorUpdate_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelMonitorUpdate obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelMonitorUpdate_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKMonitorUpdateError this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
MonitorUpdateError_free(this_obj_conv);
}
LDKMonitorUpdateError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr ret_str = MonitorUpdateError_get_a(&this_ptr_conv);
jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
Str_free(ret_str);
LDKMonitorUpdateError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr val_conv = java_to_owned_str(env, val);
MonitorUpdateError_set_a(&this_ptr_conv, val_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t MonitorUpdateError_clone_ptr(LDKMonitorUpdateError *NONNULL_PTR arg) {
+ LDKMonitorUpdateError ret_var = MonitorUpdateError_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MonitorUpdateError_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKMonitorUpdateError arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = MonitorUpdateError_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MonitorUpdateError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKMonitorUpdateError orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKMonitorUpdateError ret_var = MonitorUpdateError_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
MonitorEvent_free(this_ptr_conv);
}
+static inline uint64_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg) {
+ LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
+ *ret_copy = MonitorEvent_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MonitorEvent_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKMonitorEvent* arg_conv = (LDKMonitorEvent*)arg;
+ int64_t ret_val = MonitorEvent_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MonitorEvent_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKMonitorEvent* orig_conv = (LDKMonitorEvent*)orig;
LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
LDKHTLCUpdate a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = HTLCUpdate_clone(&a_conv);
LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
*ret_copy = MonitorEvent_htlcevent(a_conv);
LDKOutPoint a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = OutPoint_clone(&a_conv);
LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
*ret_copy = MonitorEvent_commitment_tx_confirmed(a_conv);
LDKOutPoint funding_txo_conv;
funding_txo_conv.inner = (void*)(funding_txo & (~1));
funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
funding_txo_conv = OutPoint_clone(&funding_txo_conv);
LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
*ret_copy = MonitorEvent_update_completed(funding_txo_conv, monitor_update_id);
LDKOutPoint a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = OutPoint_clone(&a_conv);
LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
*ret_copy = MonitorEvent_update_failed(a_conv);
return ret_arr;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MonitorEvent_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = (*env)->GetArrayLength(env, ser);
+ ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = MonitorEvent_read(ser_ref);
+ (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
+ return (uint64_t)ret_conv;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HTLCUpdate_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
LDKHTLCUpdate this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
HTLCUpdate_free(this_obj_conv);
}
+static inline uint64_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg) {
+ LDKHTLCUpdate ret_var = HTLCUpdate_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HTLCUpdate_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKHTLCUpdate arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = HTLCUpdate_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HTLCUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKHTLCUpdate orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKHTLCUpdate ret_var = HTLCUpdate_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKHTLCUpdate obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = HTLCUpdate_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
Balance_free(this_ptr_conv);
}
+static inline uint64_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg) {
+ LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
+ *ret_copy = Balance_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Balance_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKBalance* arg_conv = (LDKBalance*)arg;
+ int64_t ret_val = Balance_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Balance_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKBalance* orig_conv = (LDKBalance*)orig;
LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
LDKChannelMonitor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelMonitor_free(this_obj_conv);
}
+static inline uint64_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg) {
+ LDKChannelMonitor ret_var = ChannelMonitor_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelMonitor arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelMonitor_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelMonitor orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelMonitor ret_var = ChannelMonitor_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelMonitor obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelMonitor_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelMonitorUpdate updates_conv;
updates_conv.inner = (void*)(updates & (~1));
updates_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_conv);
void* broadcaster_ptr = (void*)(((uint64_t)broadcaster) & ~1);
if (!(broadcaster & 1)) { CHECK_ACCESS(broadcaster_ptr); }
LDKBroadcasterInterface* broadcaster_conv = (LDKBroadcasterInterface*)broadcaster_ptr;
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = ChannelMonitor_get_latest_update_id(&this_arg_conv);
return ret_val;
}
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
*ret_conv = ChannelMonitor_get_funding_txo(&this_arg_conv);
return ((uint64_t)ret_conv);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ret_var = ChannelMonitor_get_outputs_to_watch(&this_arg_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* filter_ptr = (void*)(((uint64_t)filter) & ~1);
if (!(filter & 1)) { CHECK_ACCESS(filter_ptr); }
LDKFilter* filter_conv = (LDKFilter*)filter_ptr;
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_MonitorEventZ ret_var = ChannelMonitor_get_and_clear_pending_monitor_events(&this_arg_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_EventZ ret_var = ChannelMonitor_get_and_clear_pending_events(&this_arg_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* logger_ptr = (void*)(((uint64_t)logger) & ~1);
if (!(logger & 1)) { CHECK_ACCESS(logger_ptr); }
LDKLogger* logger_conv = (LDKLogger*)logger_ptr;
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char header_arr[80];
CHECK((*env)->GetArrayLength(env, header) == 80);
(*env)->GetByteArrayRegion(env, header, 0, 80, header_arr);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char header_arr[80];
CHECK((*env)->GetArrayLength(env, header) == 80);
(*env)->GetByteArrayRegion(env, header, 0, 80, header_arr);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char header_arr[80];
CHECK((*env)->GetArrayLength(env, header) == 80);
(*env)->GetByteArrayRegion(env, header, 0, 80, header_arr);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char txid_arr[32];
CHECK((*env)->GetArrayLength(env, txid) == 32);
(*env)->GetByteArrayRegion(env, txid, 0, 32, txid_arr);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char header_arr[80];
CHECK((*env)->GetArrayLength(env, header) == 80);
(*env)->GetByteArrayRegion(env, header, 0, 80, header_arr);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_TxidZ ret_var = ChannelMonitor_get_relevant_txids(&this_arg_conv);
jobjectArray ret_arr = NULL;
ret_arr = (*env)->NewObjectArray(env, ret_var.datalen, arr_of_B_clz, NULL);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKBestBlock ret_var = ChannelMonitor_current_best_block(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_BalanceZ ret_var = ChannelMonitor_get_claimable_balances(&this_arg_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
LDKOutPoint this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
OutPoint_free(this_obj_conv);
}
LDKOutPoint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *OutPoint_get_txid(&this_ptr_conv));
return ret_arr;
LDKOutPoint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKOutPoint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = OutPoint_get_index(&this_ptr_conv);
return ret_val;
}
LDKOutPoint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OutPoint_set_index(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg) {
+ LDKOutPoint ret_var = OutPoint_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OutPoint_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKOutPoint arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = OutPoint_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OutPoint_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKOutPoint orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKOutPoint ret_var = OutPoint_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKOutPoint a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKOutPoint b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = OutPoint_eq(&a_conv, &b_conv);
return ret_val;
}
LDKOutPoint o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = OutPoint_hash(&o_conv);
return ret_val;
}
LDKOutPoint this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, OutPoint_to_channel_id(&this_arg_conv).data);
return ret_arr;
LDKOutPoint obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = OutPoint_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKDelayedPaymentOutputDescriptor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DelayedPaymentOutputDescriptor_free(this_obj_conv);
}
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint ret_var = DelayedPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = OutPoint_clone(&val_conv);
DelayedPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
}
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, DelayedPaymentOutputDescriptor_get_per_commitment_point(&this_ptr_conv).compressed_form);
return ret_arr;
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = DelayedPaymentOutputDescriptor_get_to_self_delay(&this_ptr_conv);
return ret_val;
}
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DelayedPaymentOutputDescriptor_set_to_self_delay(&this_ptr_conv, val);
}
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKTxOut val_conv = *(LDKTxOut*)(val_ptr);
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, DelayedPaymentOutputDescriptor_get_revocation_pubkey(&this_ptr_conv).compressed_form);
return ret_arr;
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *DelayedPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv));
return ret_arr;
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = DelayedPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
return ret_val;
}
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DelayedPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
}
LDKOutPoint outpoint_arg_conv;
outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
LDKPublicKey per_commitment_point_arg_ref;
CHECK((*env)->GetArrayLength(env, per_commitment_point_arg) == 33);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg) {
+ LDKDelayedPaymentOutputDescriptor ret_var = DelayedPaymentOutputDescriptor_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKDelayedPaymentOutputDescriptor arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = DelayedPaymentOutputDescriptor_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKDelayedPaymentOutputDescriptor orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKDelayedPaymentOutputDescriptor ret_var = DelayedPaymentOutputDescriptor_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDelayedPaymentOutputDescriptor obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = DelayedPaymentOutputDescriptor_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKStaticPaymentOutputDescriptor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
StaticPaymentOutputDescriptor_free(this_obj_conv);
}
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint ret_var = StaticPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = OutPoint_clone(&val_conv);
StaticPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
}
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKTxOut val_conv = *(LDKTxOut*)(val_ptr);
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *StaticPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv));
return ret_arr;
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = StaticPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
return ret_val;
}
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
StaticPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
}
LDKOutPoint outpoint_arg_conv;
outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
void* output_arg_ptr = (void*)(((uint64_t)output_arg) & ~1);
CHECK_ACCESS(output_arg_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg) {
+ LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKStaticPaymentOutputDescriptor arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = StaticPaymentOutputDescriptor_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKStaticPaymentOutputDescriptor orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKStaticPaymentOutputDescriptor obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = StaticPaymentOutputDescriptor_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
SpendableOutputDescriptor_free(this_ptr_conv);
}
+static inline uint64_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg) {
+ LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
+ *ret_copy = SpendableOutputDescriptor_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SpendableOutputDescriptor_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKSpendableOutputDescriptor* arg_conv = (LDKSpendableOutputDescriptor*)arg;
+ int64_t ret_val = SpendableOutputDescriptor_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SpendableOutputDescriptor_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKSpendableOutputDescriptor* orig_conv = (LDKSpendableOutputDescriptor*)orig;
LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
LDKOutPoint outpoint_conv;
outpoint_conv.inner = (void*)(outpoint & (~1));
outpoint_conv.is_owned = (outpoint & 1) || (outpoint == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_conv);
outpoint_conv = OutPoint_clone(&outpoint_conv);
void* output_ptr = (void*)(((uint64_t)output) & ~1);
CHECK_ACCESS(output_ptr);
LDKDelayedPaymentOutputDescriptor a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = DelayedPaymentOutputDescriptor_clone(&a_conv);
LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
*ret_copy = SpendableOutputDescriptor_delayed_payment_output(a_conv);
LDKStaticPaymentOutputDescriptor a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = StaticPaymentOutputDescriptor_clone(&a_conv);
LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
*ret_copy = SpendableOutputDescriptor_static_payment_output(a_conv);
BaseSign_free(this_ptr_conv);
}
+static inline uint64_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg) {
+ LDKSign* ret_ret = MALLOC(sizeof(LDKSign), "LDKSign");
+ *ret_ret = Sign_clone(arg);
+ return (uint64_t)ret_ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Sign_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ void* arg_ptr = (void*)(((uint64_t)arg) & ~1);
+ if (!(arg & 1)) { CHECK_ACCESS(arg_ptr); }
+ LDKSign* arg_conv = (LDKSign*)arg_ptr;
+ int64_t ret_val = Sign_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Sign_1clone(JNIEnv *env, jclass clz, int64_t orig) {
void* orig_ptr = (void*)(((uint64_t)orig) & ~1);
if (!(orig & 1)) { CHECK_ACCESS(orig_ptr); }
LDKInMemorySigner this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InMemorySigner_free(this_obj_conv);
}
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_funding_key(&this_ptr_conv));
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSecretKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.bytes);
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_revocation_base_key(&this_ptr_conv));
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSecretKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.bytes);
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_payment_key(&this_ptr_conv));
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSecretKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.bytes);
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_delayed_payment_base_key(&this_ptr_conv));
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSecretKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.bytes);
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_htlc_base_key(&this_ptr_conv));
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSecretKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.bytes);
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_commitment_seed(&this_ptr_conv));
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
InMemorySigner_set_commitment_seed(&this_ptr_conv, val_ref);
}
+static inline uint64_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg) {
+ LDKInMemorySigner ret_var = InMemorySigner_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKInMemorySigner arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = InMemorySigner_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKInMemorySigner orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInMemorySigner ret_var = InMemorySigner_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelPublicKeys ret_var = InMemorySigner_counterparty_pubkeys(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int16_t ret_val = InMemorySigner_counterparty_selected_contest_delay(&this_arg_conv);
return ret_val;
}
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int16_t ret_val = InMemorySigner_holder_selected_contest_delay(&this_arg_conv);
return ret_val;
}
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = InMemorySigner_is_outbound(&this_arg_conv);
return ret_val;
}
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKOutPoint ret_var = InMemorySigner_funding_outpoint(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelTransactionParameters ret_var = InMemorySigner_get_channel_parameters(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTransaction spend_tx_ref;
spend_tx_ref.datalen = (*env)->GetArrayLength(env, spend_tx);
spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
LDKStaticPaymentOutputDescriptor descriptor_conv;
descriptor_conv.inner = (void*)(descriptor & (~1));
descriptor_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(descriptor_conv);
LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
*ret_conv = InMemorySigner_sign_counterparty_payment_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
return (uint64_t)ret_conv;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTransaction spend_tx_ref;
spend_tx_ref.datalen = (*env)->GetArrayLength(env, spend_tx);
spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
LDKDelayedPaymentOutputDescriptor descriptor_conv;
descriptor_conv.inner = (void*)(descriptor & (~1));
descriptor_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(descriptor_conv);
LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
*ret_conv = InMemorySigner_sign_dynamic_p2wsh_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
return (uint64_t)ret_conv;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKBaseSign* ret_ret = MALLOC(sizeof(LDKBaseSign), "LDKBaseSign");
*ret_ret = InMemorySigner_as_BaseSign(&this_arg_conv);
return (uint64_t)ret_ret;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKSign* ret_ret = MALLOC(sizeof(LDKSign), "LDKSign");
*ret_ret = InMemorySigner_as_Sign(&this_arg_conv);
return (uint64_t)ret_ret;
LDKInMemorySigner obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = InMemorySigner_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKKeysManager this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
KeysManager_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKKeysManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char params_arr[32];
CHECK((*env)->GetArrayLength(env, params) == 32);
(*env)->GetByteArrayRegion(env, params, 0, 32, params_arr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKKeysManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_SpendableOutputDescriptorZ descriptors_constr;
descriptors_constr.datalen = (*env)->GetArrayLength(env, descriptors);
if (descriptors_constr.datalen > 0)
LDKKeysManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKKeysInterface* ret_ret = MALLOC(sizeof(LDKKeysInterface), "LDKKeysInterface");
*ret_ret = KeysManager_as_KeysInterface(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelManager_free(this_obj_conv);
}
LDKChainParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChainParameters_free(this_obj_conv);
}
LDKChainParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jclass ret_conv = LDKNetwork_to_java(env, ChainParameters_get_network(&this_ptr_conv));
return ret_conv;
}
LDKChainParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNetwork val_conv = LDKNetwork_from_java(env, val);
ChainParameters_set_network(&this_ptr_conv, val_conv);
}
LDKChainParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKBestBlock ret_var = ChainParameters_get_best_block(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChainParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKBestBlock val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = BestBlock_clone(&val_conv);
ChainParameters_set_best_block(&this_ptr_conv, val_conv);
}
LDKBestBlock best_block_arg_conv;
best_block_arg_conv.inner = (void*)(best_block_arg & (~1));
best_block_arg_conv.is_owned = (best_block_arg & 1) || (best_block_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(best_block_arg_conv);
best_block_arg_conv = BestBlock_clone(&best_block_arg_conv);
LDKChainParameters ret_var = ChainParameters_new(network_arg_conv, best_block_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg) {
+ LDKChainParameters ret_var = ChainParameters_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChainParameters_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChainParameters arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChainParameters_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChainParameters_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChainParameters orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChainParameters ret_var = ChainParameters_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCounterpartyForwardingInfo this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
CounterpartyForwardingInfo_free(this_obj_conv);
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = CounterpartyForwardingInfo_get_fee_base_msat(&this_ptr_conv);
return ret_val;
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
CounterpartyForwardingInfo_set_fee_base_msat(&this_ptr_conv, val);
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = CounterpartyForwardingInfo_get_fee_proportional_millionths(&this_ptr_conv);
return ret_val;
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
CounterpartyForwardingInfo_set_fee_proportional_millionths(&this_ptr_conv, val);
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = CounterpartyForwardingInfo_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
CounterpartyForwardingInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg) {
+ LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CounterpartyForwardingInfo_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCounterpartyForwardingInfo arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = CounterpartyForwardingInfo_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CounterpartyForwardingInfo_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCounterpartyForwardingInfo orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelCounterparty this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelCounterparty_free(this_obj_conv);
}
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelCounterparty_get_node_id(&this_ptr_conv).compressed_form);
return ret_arr;
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInitFeatures ret_var = ChannelCounterparty_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInitFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = InitFeatures_clone(&val_conv);
ChannelCounterparty_set_features(&this_ptr_conv, val_conv);
}
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelCounterparty_get_unspendable_punishment_reserve(&this_ptr_conv);
return ret_val;
}
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelCounterparty_set_unspendable_punishment_reserve(&this_ptr_conv, val);
}
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCounterpartyForwardingInfo ret_var = ChannelCounterparty_get_forwarding_info(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCounterpartyForwardingInfo val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = CounterpartyForwardingInfo_clone(&val_conv);
ChannelCounterparty_set_forwarding_info(&this_ptr_conv, val_conv);
}
LDKInitFeatures features_arg_conv;
features_arg_conv.inner = (void*)(features_arg & (~1));
features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
features_arg_conv = InitFeatures_clone(&features_arg_conv);
LDKCounterpartyForwardingInfo forwarding_info_arg_conv;
forwarding_info_arg_conv.inner = (void*)(forwarding_info_arg & (~1));
forwarding_info_arg_conv.is_owned = (forwarding_info_arg & 1) || (forwarding_info_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(forwarding_info_arg_conv);
forwarding_info_arg_conv = CounterpartyForwardingInfo_clone(&forwarding_info_arg_conv);
LDKChannelCounterparty ret_var = ChannelCounterparty_new(node_id_arg_ref, features_arg_conv, unspendable_punishment_reserve_arg, forwarding_info_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg) {
+ LDKChannelCounterparty ret_var = ChannelCounterparty_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelCounterparty_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelCounterparty arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelCounterparty_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelCounterparty_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelCounterparty orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelCounterparty ret_var = ChannelCounterparty_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelDetails this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelDetails_free(this_obj_conv);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ChannelDetails_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelCounterparty ret_var = ChannelDetails_get_counterparty(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelCounterparty val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelCounterparty_clone(&val_conv);
ChannelDetails_set_counterparty(&this_ptr_conv, val_conv);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint ret_var = ChannelDetails_get_funding_txo(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = OutPoint_clone(&val_conv);
ChannelDetails_set_funding_txo(&this_ptr_conv, val_conv);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = ChannelDetails_get_short_channel_id(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelDetails_get_channel_value_satoshis(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_channel_value_satoshis(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = ChannelDetails_get_unspendable_punishment_reserve(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelDetails_get_user_channel_id(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_user_channel_id(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelDetails_get_outbound_capacity_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_outbound_capacity_msat(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelDetails_get_inbound_capacity_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_inbound_capacity_msat(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
*ret_copy = ChannelDetails_get_confirmations_required(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
*ret_copy = ChannelDetails_get_force_close_spend_delay(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u16Z val_conv = *(LDKCOption_u16Z*)(val_ptr);
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelDetails_get_is_outbound(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_is_outbound(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelDetails_get_is_funding_locked(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_is_funding_locked(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelDetails_get_is_usable(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_is_usable(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelDetails_get_is_public(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_is_public(&this_ptr_conv, val);
}
LDKChannelCounterparty counterparty_arg_conv;
counterparty_arg_conv.inner = (void*)(counterparty_arg & (~1));
counterparty_arg_conv.is_owned = (counterparty_arg & 1) || (counterparty_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(counterparty_arg_conv);
counterparty_arg_conv = ChannelCounterparty_clone(&counterparty_arg_conv);
LDKOutPoint funding_txo_arg_conv;
funding_txo_arg_conv.inner = (void*)(funding_txo_arg & (~1));
funding_txo_arg_conv.is_owned = (funding_txo_arg & 1) || (funding_txo_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_arg_conv);
funding_txo_arg_conv = OutPoint_clone(&funding_txo_arg_conv);
void* short_channel_id_arg_ptr = (void*)(((uint64_t)short_channel_id_arg) & ~1);
CHECK_ACCESS(short_channel_id_arg_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg) {
+ LDKChannelDetails ret_var = ChannelDetails_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelDetails arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelDetails_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelDetails orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelDetails ret_var = ChannelDetails_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
PaymentSendFailure_free(this_ptr_conv);
}
+static inline uint64_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg) {
+ LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
+ *ret_copy = PaymentSendFailure_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PaymentSendFailure_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKPaymentSendFailure* arg_conv = (LDKPaymentSendFailure*)arg;
+ int64_t ret_val = PaymentSendFailure_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PaymentSendFailure_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKPaymentSendFailure* orig_conv = (LDKPaymentSendFailure*)orig;
LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
LDKRouteParameters failed_paths_retry_conv;
failed_paths_retry_conv.inner = (void*)(failed_paths_retry & (~1));
failed_paths_retry_conv.is_owned = (failed_paths_retry & 1) || (failed_paths_retry == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(failed_paths_retry_conv);
failed_paths_retry_conv = RouteParameters_clone(&failed_paths_retry_conv);
LDKThirtyTwoBytes payment_id_ref;
CHECK((*env)->GetArrayLength(env, payment_id) == 32);
LDKUserConfig config_conv;
config_conv.inner = (void*)(config & (~1));
config_conv.is_owned = (config & 1) || (config == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(config_conv);
config_conv = UserConfig_clone(&config_conv);
LDKChainParameters params_conv;
params_conv.inner = (void*)(params & (~1));
params_conv.is_owned = (params & 1) || (params == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
params_conv = ChainParameters_clone(¶ms_conv);
LDKChannelManager ret_var = ChannelManager_new(fee_est_conv, chain_monitor_conv, tx_broadcaster_conv, logger_conv, keys_manager_conv, config_conv, params_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKUserConfig ret_var = ChannelManager_get_current_default_configuration(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPublicKey their_network_key_ref;
CHECK((*env)->GetArrayLength(env, their_network_key) == 33);
(*env)->GetByteArrayRegion(env, their_network_key, 0, 33, their_network_key_ref.compressed_form);
LDKUserConfig override_config_conv;
override_config_conv.inner = (void*)(override_config & (~1));
override_config_conv.is_owned = (override_config & 1) || (override_config == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(override_config_conv);
override_config_conv = UserConfig_clone(&override_config_conv);
LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
*ret_conv = ChannelManager_create_channel(&this_arg_conv, their_network_key_ref, channel_value_satoshis, push_msat, user_channel_id, override_config_conv);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_channels(&this_arg_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_16_ref = 0;
CHECK((((uint64_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
ret_conv_16_ref = (uint64_t)ret_conv_16_var.inner;
if (ret_conv_16_var.is_owned) {
ret_conv_16_ref |= 1;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_usable_channels(&this_arg_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_16_ref = 0;
CHECK((((uint64_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
ret_conv_16_ref = (uint64_t)ret_conv_16_var.inner;
if (ret_conv_16_var.is_owned) {
ret_conv_16_ref |= 1;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char channel_id_arr[32];
CHECK((*env)->GetArrayLength(env, channel_id) == 32);
(*env)->GetByteArrayRegion(env, channel_id, 0, 32, channel_id_arr);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char channel_id_arr[32];
CHECK((*env)->GetArrayLength(env, channel_id) == 32);
(*env)->GetByteArrayRegion(env, channel_id, 0, 32, channel_id_arr);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char channel_id_arr[32];
CHECK((*env)->GetArrayLength(env, channel_id) == 32);
(*env)->GetByteArrayRegion(env, channel_id, 0, 32, channel_id_arr);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
ChannelManager_force_close_all_channels(&this_arg_conv);
}
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRoute route_conv;
route_conv.inner = (void*)(route & (~1));
route_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
LDKThirtyTwoBytes payment_hash_ref;
CHECK((*env)->GetArrayLength(env, payment_hash) == 32);
(*env)->GetByteArrayRegion(env, payment_hash, 0, 32, payment_hash_ref.data);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRoute route_conv;
route_conv.inner = (void*)(route & (~1));
route_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
LDKThirtyTwoBytes payment_id_ref;
CHECK((*env)->GetArrayLength(env, payment_id) == 32);
(*env)->GetByteArrayRegion(env, payment_id, 0, 32, payment_id_ref.data);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRoute route_conv;
route_conv.inner = (void*)(route & (~1));
route_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
LDKThirtyTwoBytes payment_preimage_ref;
CHECK((*env)->GetArrayLength(env, payment_preimage) == 32);
(*env)->GetByteArrayRegion(env, payment_preimage, 0, 32, payment_preimage_ref.data);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char temporary_channel_id_arr[32];
CHECK((*env)->GetArrayLength(env, temporary_channel_id) == 32);
(*env)->GetByteArrayRegion(env, temporary_channel_id, 0, 32, temporary_channel_id_arr);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKThreeBytes rgb_ref;
CHECK((*env)->GetArrayLength(env, rgb) == 3);
(*env)->GetByteArrayRegion(env, rgb, 0, 3, rgb_ref.data);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
ChannelManager_process_pending_htlc_forwards(&this_arg_conv);
}
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
ChannelManager_timer_tick_occurred(&this_arg_conv);
}
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char payment_hash_arr[32];
CHECK((*env)->GetArrayLength(env, payment_hash) == 32);
(*env)->GetByteArrayRegion(env, payment_hash, 0, 32, payment_hash_arr);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKThirtyTwoBytes payment_preimage_ref;
CHECK((*env)->GetArrayLength(env, payment_preimage) == 32);
(*env)->GetByteArrayRegion(env, payment_preimage, 0, 32, payment_preimage_ref.data);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelManager_get_our_node_id(&this_arg_conv).compressed_form);
return ret_arr;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* min_value_msat_ptr = (void*)(((uint64_t)min_value_msat) & ~1);
CHECK_ACCESS(min_value_msat_ptr);
LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKThirtyTwoBytes payment_hash_ref;
CHECK((*env)->GetArrayLength(env, payment_hash) == 32);
(*env)->GetByteArrayRegion(env, payment_hash, 0, 32, payment_hash_ref.data);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
*ret_ret = ChannelManager_as_MessageSendEventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKEventsProvider* ret_ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
*ret_ret = ChannelManager_as_EventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKListen* ret_ret = MALLOC(sizeof(LDKListen), "LDKListen");
*ret_ret = ChannelManager_as_Listen(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKConfirm* ret_ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
*ret_ret = ChannelManager_as_Confirm(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = ChannelManager_await_persistable_update_timeout(&this_arg_conv, max_wait);
return ret_val;
}
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
ChannelManager_await_persistable_update(&this_arg_conv);
}
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKBestBlock ret_var = ChannelManager_current_best_block(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelMessageHandler* ret_ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
*ret_ret = ChannelManager_as_ChannelMessageHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelManager_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKChannelManagerReadArgs this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelManagerReadArgs_free(this_obj_conv);
}
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)ChannelManagerReadArgs_get_keys_manager(&this_ptr_conv)) | 1;
return ret_ret;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKKeysInterface val_conv = *(LDKKeysInterface*)(val_ptr);
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)ChannelManagerReadArgs_get_fee_estimator(&this_ptr_conv)) | 1;
return ret_ret;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKFeeEstimator val_conv = *(LDKFeeEstimator*)(val_ptr);
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)ChannelManagerReadArgs_get_chain_monitor(&this_ptr_conv)) | 1;
return ret_ret;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKWatch val_conv = *(LDKWatch*)(val_ptr);
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)ChannelManagerReadArgs_get_tx_broadcaster(&this_ptr_conv)) | 1;
return ret_ret;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKBroadcasterInterface val_conv = *(LDKBroadcasterInterface*)(val_ptr);
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)ChannelManagerReadArgs_get_logger(&this_ptr_conv)) | 1;
return ret_ret;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKLogger val_conv = *(LDKLogger*)(val_ptr);
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUserConfig ret_var = ChannelManagerReadArgs_get_default_config(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUserConfig val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = UserConfig_clone(&val_conv);
ChannelManagerReadArgs_set_default_config(&this_ptr_conv, val_conv);
}
LDKUserConfig default_config_conv;
default_config_conv.inner = (void*)(default_config & (~1));
default_config_conv.is_owned = (default_config & 1) || (default_config == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(default_config_conv);
default_config_conv = UserConfig_clone(&default_config_conv);
LDKCVec_ChannelMonitorZ channel_monitors_constr;
channel_monitors_constr.datalen = (*env)->GetArrayLength(env, channel_monitors);
LDKChannelMonitor channel_monitors_conv_16_conv;
channel_monitors_conv_16_conv.inner = (void*)(channel_monitors_conv_16 & (~1));
channel_monitors_conv_16_conv.is_owned = (channel_monitors_conv_16 & 1) || (channel_monitors_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_monitors_conv_16_conv);
channel_monitors_constr.data[q] = channel_monitors_conv_16_conv;
}
(*env)->ReleaseLongArrayElements(env, channel_monitors, channel_monitors_vals, 0);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelManagerReadArgs arg_conv;
arg_conv.inner = (void*)(arg & (~1));
arg_conv.is_owned = (arg & 1) || (arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
// Warning: we need a move here but no clone is available for LDKChannelManagerReadArgs
LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
*ret_conv = C2Tuple_BlockHashChannelManagerZ_read(ser_ref, arg_conv);
LDKDecodeError this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DecodeError_free(this_obj_conv);
}
+static inline uint64_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg) {
+ LDKDecodeError ret_var = DecodeError_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DecodeError_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKDecodeError arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = DecodeError_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DecodeError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKDecodeError orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKDecodeError ret_var = DecodeError_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInit this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Init_free(this_obj_conv);
}
LDKInit this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInitFeatures ret_var = Init_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInit this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInitFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = InitFeatures_clone(&val_conv);
Init_set_features(&this_ptr_conv, val_conv);
}
LDKInitFeatures features_arg_conv;
features_arg_conv.inner = (void*)(features_arg & (~1));
features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
features_arg_conv = InitFeatures_clone(&features_arg_conv);
LDKInit ret_var = Init_new(features_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Init_clone_ptr(LDKInit *NONNULL_PTR arg) {
+ LDKInit ret_var = Init_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Init_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKInit arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Init_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Init_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKInit orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInit ret_var = Init_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKErrorMessage this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ErrorMessage_free(this_obj_conv);
}
LDKErrorMessage this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ErrorMessage_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKErrorMessage this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKErrorMessage this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr ret_str = ErrorMessage_get_data(&this_ptr_conv);
jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
Str_free(ret_str);
LDKErrorMessage this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr val_conv = java_to_owned_str(env, val);
ErrorMessage_set_data(&this_ptr_conv, val_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg) {
+ LDKErrorMessage ret_var = ErrorMessage_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKErrorMessage arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ErrorMessage_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKErrorMessage orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKErrorMessage ret_var = ErrorMessage_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPing this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Ping_free(this_obj_conv);
}
LDKPing this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = Ping_get_ponglen(&this_ptr_conv);
return ret_val;
}
LDKPing this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
Ping_set_ponglen(&this_ptr_conv, val);
}
LDKPing this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = Ping_get_byteslen(&this_ptr_conv);
return ret_val;
}
LDKPing this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
Ping_set_byteslen(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg) {
+ LDKPing ret_var = Ping_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Ping_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKPing arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Ping_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Ping_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKPing orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPing ret_var = Ping_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPong this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Pong_free(this_obj_conv);
}
LDKPong this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = Pong_get_byteslen(&this_ptr_conv);
return ret_val;
}
LDKPong this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
Pong_set_byteslen(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg) {
+ LDKPong ret_var = Pong_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Pong_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKPong arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Pong_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Pong_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKPong orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPong ret_var = Pong_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKOpenChannel this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
OpenChannel_free(this_obj_conv);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *OpenChannel_get_chain_hash(&this_ptr_conv));
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *OpenChannel_get_temporary_channel_id(&this_ptr_conv));
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_funding_satoshis(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_funding_satoshis(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_push_msat(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_push_msat(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_dust_limit_satoshis(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_channel_reserve_satoshis(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = OpenChannel_get_feerate_per_kw(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_feerate_per_kw(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = OpenChannel_get_to_self_delay(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_to_self_delay(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = OpenChannel_get_max_accepted_htlcs(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_funding_pubkey(&this_ptr_conv).compressed_form);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_payment_point(&this_ptr_conv).compressed_form);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_t ret_val = OpenChannel_get_channel_flags(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_channel_flags(&this_ptr_conv, val);
}
+static inline uint64_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg) {
+ LDKOpenChannel ret_var = OpenChannel_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKOpenChannel arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = OpenChannel_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKOpenChannel orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKOpenChannel ret_var = OpenChannel_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKAcceptChannel this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
AcceptChannel_free(this_obj_conv);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *AcceptChannel_get_temporary_channel_id(&this_ptr_conv));
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = AcceptChannel_get_dust_limit_satoshis(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = AcceptChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = AcceptChannel_get_channel_reserve_satoshis(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = AcceptChannel_get_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = AcceptChannel_get_minimum_depth(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_minimum_depth(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = AcceptChannel_get_to_self_delay(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_to_self_delay(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = AcceptChannel_get_max_accepted_htlcs(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_funding_pubkey(&this_ptr_conv).compressed_form);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_payment_point(&this_ptr_conv).compressed_form);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
AcceptChannel_set_first_per_commitment_point(&this_ptr_conv, val_ref);
}
+static inline uint64_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg) {
+ LDKAcceptChannel ret_var = AcceptChannel_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKAcceptChannel arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = AcceptChannel_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKAcceptChannel orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKAcceptChannel ret_var = AcceptChannel_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKFundingCreated this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
FundingCreated_free(this_obj_conv);
}
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *FundingCreated_get_temporary_channel_id(&this_ptr_conv));
return ret_arr;
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *FundingCreated_get_funding_txid(&this_ptr_conv));
return ret_arr;
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = FundingCreated_get_funding_output_index(&this_ptr_conv);
return ret_val;
}
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
FundingCreated_set_funding_output_index(&this_ptr_conv, val);
}
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, FundingCreated_get_signature(&this_ptr_conv).compact_form);
return ret_arr;
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg) {
+ LDKFundingCreated ret_var = FundingCreated_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingCreated_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKFundingCreated arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = FundingCreated_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingCreated_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKFundingCreated orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKFundingCreated ret_var = FundingCreated_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKFundingSigned this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
FundingSigned_free(this_obj_conv);
}
LDKFundingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *FundingSigned_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKFundingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKFundingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, FundingSigned_get_signature(&this_ptr_conv).compact_form);
return ret_arr;
LDKFundingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg) {
+ LDKFundingSigned ret_var = FundingSigned_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingSigned_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKFundingSigned arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = FundingSigned_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingSigned_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKFundingSigned orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKFundingSigned ret_var = FundingSigned_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKFundingLocked this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
FundingLocked_free(this_obj_conv);
}
LDKFundingLocked this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *FundingLocked_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKFundingLocked this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKFundingLocked this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, FundingLocked_get_next_per_commitment_point(&this_ptr_conv).compressed_form);
return ret_arr;
LDKFundingLocked this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t FundingLocked_clone_ptr(LDKFundingLocked *NONNULL_PTR arg) {
+ LDKFundingLocked ret_var = FundingLocked_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingLocked_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKFundingLocked arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = FundingLocked_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingLocked_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKFundingLocked orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKFundingLocked ret_var = FundingLocked_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKShutdown this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Shutdown_free(this_obj_conv);
}
LDKShutdown this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *Shutdown_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKShutdown this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKShutdown this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKu8slice ret_var = Shutdown_get_scriptpubkey(&this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKShutdown this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u8Z val_ref;
val_ref.datalen = (*env)->GetArrayLength(env, val);
val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg) {
+ LDKShutdown ret_var = Shutdown_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Shutdown_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKShutdown arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Shutdown_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Shutdown_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKShutdown orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKShutdown ret_var = Shutdown_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingSignedFeeRange this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ClosingSignedFeeRange_free(this_obj_conv);
}
LDKClosingSignedFeeRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ClosingSignedFeeRange_get_min_fee_satoshis(&this_ptr_conv);
return ret_val;
}
LDKClosingSignedFeeRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ClosingSignedFeeRange_set_min_fee_satoshis(&this_ptr_conv, val);
}
LDKClosingSignedFeeRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ClosingSignedFeeRange_get_max_fee_satoshis(&this_ptr_conv);
return ret_val;
}
LDKClosingSignedFeeRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ClosingSignedFeeRange_set_max_fee_satoshis(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg) {
+ LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosingSignedFeeRange_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKClosingSignedFeeRange arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ClosingSignedFeeRange_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosingSignedFeeRange_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKClosingSignedFeeRange orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingSigned this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ClosingSigned_free(this_obj_conv);
}
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ClosingSigned_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ClosingSigned_get_fee_satoshis(&this_ptr_conv);
return ret_val;
}
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ClosingSigned_set_fee_satoshis(&this_ptr_conv, val);
}
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ClosingSigned_get_signature(&this_ptr_conv).compact_form);
return ret_arr;
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKClosingSignedFeeRange ret_var = ClosingSigned_get_fee_range(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKClosingSignedFeeRange val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ClosingSignedFeeRange_clone(&val_conv);
ClosingSigned_set_fee_range(&this_ptr_conv, val_conv);
}
LDKClosingSignedFeeRange fee_range_arg_conv;
fee_range_arg_conv.inner = (void*)(fee_range_arg & (~1));
fee_range_arg_conv.is_owned = (fee_range_arg & 1) || (fee_range_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(fee_range_arg_conv);
fee_range_arg_conv = ClosingSignedFeeRange_clone(&fee_range_arg_conv);
LDKClosingSigned ret_var = ClosingSigned_new(channel_id_arg_ref, fee_satoshis_arg, signature_arg_ref, fee_range_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg) {
+ LDKClosingSigned ret_var = ClosingSigned_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKClosingSigned arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ClosingSigned_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKClosingSigned orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKClosingSigned ret_var = ClosingSigned_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUpdateAddHTLC this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UpdateAddHTLC_free(this_obj_conv);
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateAddHTLC_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UpdateAddHTLC_get_htlc_id(&this_ptr_conv);
return ret_val;
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateAddHTLC_set_htlc_id(&this_ptr_conv, val);
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UpdateAddHTLC_get_amount_msat(&this_ptr_conv);
return ret_val;
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateAddHTLC_set_amount_msat(&this_ptr_conv, val);
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateAddHTLC_get_payment_hash(&this_ptr_conv));
return ret_arr;
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UpdateAddHTLC_get_cltv_expiry(&this_ptr_conv);
return ret_val;
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateAddHTLC_set_cltv_expiry(&this_ptr_conv, val);
}
+static inline uint64_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg) {
+ LDKUpdateAddHTLC ret_var = UpdateAddHTLC_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKUpdateAddHTLC arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UpdateAddHTLC_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKUpdateAddHTLC orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUpdateAddHTLC ret_var = UpdateAddHTLC_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUpdateFulfillHTLC this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UpdateFulfillHTLC_free(this_obj_conv);
}
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateFulfillHTLC_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UpdateFulfillHTLC_get_htlc_id(&this_ptr_conv);
return ret_val;
}
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateFulfillHTLC_set_htlc_id(&this_ptr_conv, val);
}
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateFulfillHTLC_get_payment_preimage(&this_ptr_conv));
return ret_arr;
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg) {
+ LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKUpdateFulfillHTLC arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UpdateFulfillHTLC_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKUpdateFulfillHTLC orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUpdateFailHTLC this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UpdateFailHTLC_free(this_obj_conv);
}
LDKUpdateFailHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateFailHTLC_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKUpdateFailHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKUpdateFailHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UpdateFailHTLC_get_htlc_id(&this_ptr_conv);
return ret_val;
}
LDKUpdateFailHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateFailHTLC_set_htlc_id(&this_ptr_conv, val);
}
+static inline uint64_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg) {
+ LDKUpdateFailHTLC ret_var = UpdateFailHTLC_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFailHTLC_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKUpdateFailHTLC arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UpdateFailHTLC_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFailHTLC_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKUpdateFailHTLC orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUpdateFailHTLC ret_var = UpdateFailHTLC_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUpdateFailMalformedHTLC this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UpdateFailMalformedHTLC_free(this_obj_conv);
}
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateFailMalformedHTLC_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UpdateFailMalformedHTLC_get_htlc_id(&this_ptr_conv);
return ret_val;
}
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateFailMalformedHTLC_set_htlc_id(&this_ptr_conv, val);
}
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = UpdateFailMalformedHTLC_get_failure_code(&this_ptr_conv);
return ret_val;
}
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateFailMalformedHTLC_set_failure_code(&this_ptr_conv, val);
}
+static inline uint64_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg) {
+ LDKUpdateFailMalformedHTLC ret_var = UpdateFailMalformedHTLC_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKUpdateFailMalformedHTLC arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UpdateFailMalformedHTLC_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKUpdateFailMalformedHTLC orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUpdateFailMalformedHTLC ret_var = UpdateFailMalformedHTLC_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentSigned this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
CommitmentSigned_free(this_obj_conv);
}
LDKCommitmentSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *CommitmentSigned_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKCommitmentSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKCommitmentSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, CommitmentSigned_get_signature(&this_ptr_conv).compact_form);
return ret_arr;
LDKCommitmentSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
LDKCommitmentSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_SignatureZ val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg) {
+ LDKCommitmentSigned ret_var = CommitmentSigned_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCommitmentSigned arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = CommitmentSigned_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCommitmentSigned orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKCommitmentSigned ret_var = CommitmentSigned_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRevokeAndACK this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RevokeAndACK_free(this_obj_conv);
}
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *RevokeAndACK_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *RevokeAndACK_get_per_commitment_secret(&this_ptr_conv));
return ret_arr;
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, RevokeAndACK_get_next_per_commitment_point(&this_ptr_conv).compressed_form);
return ret_arr;
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg) {
+ LDKRevokeAndACK ret_var = RevokeAndACK_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKRevokeAndACK arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RevokeAndACK_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKRevokeAndACK orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRevokeAndACK ret_var = RevokeAndACK_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUpdateFee this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UpdateFee_free(this_obj_conv);
}
LDKUpdateFee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateFee_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKUpdateFee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKUpdateFee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UpdateFee_get_feerate_per_kw(&this_ptr_conv);
return ret_val;
}
LDKUpdateFee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateFee_set_feerate_per_kw(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg) {
+ LDKUpdateFee ret_var = UpdateFee_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFee_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKUpdateFee arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UpdateFee_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFee_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKUpdateFee orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUpdateFee ret_var = UpdateFee_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDataLossProtect this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DataLossProtect_free(this_obj_conv);
}
LDKDataLossProtect this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *DataLossProtect_get_your_last_per_commitment_secret(&this_ptr_conv));
return ret_arr;
LDKDataLossProtect this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKDataLossProtect this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, DataLossProtect_get_my_current_per_commitment_point(&this_ptr_conv).compressed_form);
return ret_arr;
LDKDataLossProtect this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg) {
+ LDKDataLossProtect ret_var = DataLossProtect_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DataLossProtect_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKDataLossProtect arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = DataLossProtect_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DataLossProtect_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKDataLossProtect orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKDataLossProtect ret_var = DataLossProtect_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelReestablish this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelReestablish_free(this_obj_conv);
}
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ChannelReestablish_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelReestablish_get_next_local_commitment_number(&this_ptr_conv);
return ret_val;
}
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelReestablish_set_next_local_commitment_number(&this_ptr_conv, val);
}
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelReestablish_get_next_remote_commitment_number(&this_ptr_conv);
return ret_val;
}
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelReestablish_set_next_remote_commitment_number(&this_ptr_conv, val);
}
+static inline uint64_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg) {
+ LDKChannelReestablish ret_var = ChannelReestablish_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelReestablish arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelReestablish_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelReestablish orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelReestablish ret_var = ChannelReestablish_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKAnnouncementSignatures this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
AnnouncementSignatures_free(this_obj_conv);
}
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *AnnouncementSignatures_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = AnnouncementSignatures_get_short_channel_id(&this_ptr_conv);
return ret_val;
}
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AnnouncementSignatures_set_short_channel_id(&this_ptr_conv, val);
}
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, AnnouncementSignatures_get_node_signature(&this_ptr_conv).compact_form);
return ret_arr;
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, AnnouncementSignatures_get_bitcoin_signature(&this_ptr_conv).compact_form);
return ret_arr;
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg) {
+ LDKAnnouncementSignatures ret_var = AnnouncementSignatures_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKAnnouncementSignatures arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = AnnouncementSignatures_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKAnnouncementSignatures orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKAnnouncementSignatures ret_var = AnnouncementSignatures_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
NetAddress_free(this_ptr_conv);
}
+static inline uint64_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg) {
+ LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
+ *ret_copy = NetAddress_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetAddress_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKNetAddress* arg_conv = (LDKNetAddress*)arg;
+ int64_t ret_val = NetAddress_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetAddress_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKNetAddress* orig_conv = (LDKNetAddress*)orig;
LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
LDKUnsignedNodeAnnouncement this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UnsignedNodeAnnouncement_free(this_obj_conv);
}
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures ret_var = UnsignedNodeAnnouncement_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeFeatures_clone(&val_conv);
UnsignedNodeAnnouncement_set_features(&this_ptr_conv, val_conv);
}
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UnsignedNodeAnnouncement_get_timestamp(&this_ptr_conv);
return ret_val;
}
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedNodeAnnouncement_set_timestamp(&this_ptr_conv, val);
}
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, UnsignedNodeAnnouncement_get_node_id(&this_ptr_conv).compressed_form);
return ret_arr;
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 3);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 3, *UnsignedNodeAnnouncement_get_rgb(&this_ptr_conv));
return ret_arr;
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThreeBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 3);
(*env)->GetByteArrayRegion(env, val, 0, 3, val_ref.data);
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UnsignedNodeAnnouncement_get_alias(&this_ptr_conv));
return ret_arr;
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_NetAddressZ val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
UnsignedNodeAnnouncement_set_addresses(&this_ptr_conv, val_constr);
}
+static inline uint64_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg) {
+ LDKUnsignedNodeAnnouncement ret_var = UnsignedNodeAnnouncement_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKUnsignedNodeAnnouncement arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UnsignedNodeAnnouncement_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKUnsignedNodeAnnouncement orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUnsignedNodeAnnouncement ret_var = UnsignedNodeAnnouncement_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeAnnouncement this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NodeAnnouncement_free(this_obj_conv);
}
LDKNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, NodeAnnouncement_get_signature(&this_ptr_conv).compact_form);
return ret_arr;
LDKNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
LDKNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedNodeAnnouncement ret_var = NodeAnnouncement_get_contents(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedNodeAnnouncement val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = UnsignedNodeAnnouncement_clone(&val_conv);
NodeAnnouncement_set_contents(&this_ptr_conv, val_conv);
}
LDKUnsignedNodeAnnouncement contents_arg_conv;
contents_arg_conv.inner = (void*)(contents_arg & (~1));
contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
contents_arg_conv = UnsignedNodeAnnouncement_clone(&contents_arg_conv);
LDKNodeAnnouncement ret_var = NodeAnnouncement_new(signature_arg_ref, contents_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg) {
+ LDKNodeAnnouncement ret_var = NodeAnnouncement_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKNodeAnnouncement arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NodeAnnouncement_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKNodeAnnouncement orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNodeAnnouncement ret_var = NodeAnnouncement_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUnsignedChannelAnnouncement this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UnsignedChannelAnnouncement_free(this_obj_conv);
}
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures ret_var = UnsignedChannelAnnouncement_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelFeatures_clone(&val_conv);
UnsignedChannelAnnouncement_set_features(&this_ptr_conv, val_conv);
}
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UnsignedChannelAnnouncement_get_chain_hash(&this_ptr_conv));
return ret_arr;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UnsignedChannelAnnouncement_get_short_channel_id(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelAnnouncement_set_short_channel_id(&this_ptr_conv, val);
}
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, UnsignedChannelAnnouncement_get_node_id_1(&this_ptr_conv).compressed_form);
return ret_arr;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, UnsignedChannelAnnouncement_get_node_id_2(&this_ptr_conv).compressed_form);
return ret_arr;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, UnsignedChannelAnnouncement_get_bitcoin_key_1(&this_ptr_conv).compressed_form);
return ret_arr;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, UnsignedChannelAnnouncement_get_bitcoin_key_2(&this_ptr_conv).compressed_form);
return ret_arr;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
UnsignedChannelAnnouncement_set_bitcoin_key_2(&this_ptr_conv, val_ref);
}
+static inline uint64_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg) {
+ LDKUnsignedChannelAnnouncement ret_var = UnsignedChannelAnnouncement_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKUnsignedChannelAnnouncement arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UnsignedChannelAnnouncement_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKUnsignedChannelAnnouncement orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUnsignedChannelAnnouncement ret_var = UnsignedChannelAnnouncement_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelAnnouncement this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelAnnouncement_free(this_obj_conv);
}
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ChannelAnnouncement_get_node_signature_1(&this_ptr_conv).compact_form);
return ret_arr;
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ChannelAnnouncement_get_node_signature_2(&this_ptr_conv).compact_form);
return ret_arr;
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ChannelAnnouncement_get_bitcoin_signature_1(&this_ptr_conv).compact_form);
return ret_arr;
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ChannelAnnouncement_get_bitcoin_signature_2(&this_ptr_conv).compact_form);
return ret_arr;
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedChannelAnnouncement ret_var = ChannelAnnouncement_get_contents(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedChannelAnnouncement val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = UnsignedChannelAnnouncement_clone(&val_conv);
ChannelAnnouncement_set_contents(&this_ptr_conv, val_conv);
}
LDKUnsignedChannelAnnouncement contents_arg_conv;
contents_arg_conv.inner = (void*)(contents_arg & (~1));
contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
contents_arg_conv = UnsignedChannelAnnouncement_clone(&contents_arg_conv);
LDKChannelAnnouncement ret_var = ChannelAnnouncement_new(node_signature_1_arg_ref, node_signature_2_arg_ref, bitcoin_signature_1_arg_ref, bitcoin_signature_2_arg_ref, contents_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg) {
+ LDKChannelAnnouncement ret_var = ChannelAnnouncement_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelAnnouncement arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelAnnouncement_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelAnnouncement orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelAnnouncement ret_var = ChannelAnnouncement_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUnsignedChannelUpdate this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UnsignedChannelUpdate_free(this_obj_conv);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UnsignedChannelUpdate_get_chain_hash(&this_ptr_conv));
return ret_arr;
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UnsignedChannelUpdate_get_short_channel_id(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_short_channel_id(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UnsignedChannelUpdate_get_timestamp(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_timestamp(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_t ret_val = UnsignedChannelUpdate_get_flags(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_flags(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = UnsignedChannelUpdate_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UnsignedChannelUpdate_get_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_htlc_minimum_msat(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UnsignedChannelUpdate_get_fee_base_msat(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_fee_base_msat(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UnsignedChannelUpdate_get_fee_proportional_millionths(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_fee_proportional_millionths(&this_ptr_conv, val);
}
+static inline uint64_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg) {
+ LDKUnsignedChannelUpdate ret_var = UnsignedChannelUpdate_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKUnsignedChannelUpdate arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UnsignedChannelUpdate_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKUnsignedChannelUpdate orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUnsignedChannelUpdate ret_var = UnsignedChannelUpdate_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelUpdate this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelUpdate_free(this_obj_conv);
}
LDKChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ChannelUpdate_get_signature(&this_ptr_conv).compact_form);
return ret_arr;
LDKChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
LDKChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedChannelUpdate ret_var = ChannelUpdate_get_contents(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedChannelUpdate val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = UnsignedChannelUpdate_clone(&val_conv);
ChannelUpdate_set_contents(&this_ptr_conv, val_conv);
}
LDKUnsignedChannelUpdate contents_arg_conv;
contents_arg_conv.inner = (void*)(contents_arg & (~1));
contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
contents_arg_conv = UnsignedChannelUpdate_clone(&contents_arg_conv);
LDKChannelUpdate ret_var = ChannelUpdate_new(signature_arg_ref, contents_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg) {
+ LDKChannelUpdate ret_var = ChannelUpdate_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelUpdate arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelUpdate_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelUpdate orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelUpdate ret_var = ChannelUpdate_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKQueryChannelRange this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
QueryChannelRange_free(this_obj_conv);
}
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *QueryChannelRange_get_chain_hash(&this_ptr_conv));
return ret_arr;
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = QueryChannelRange_get_first_blocknum(&this_ptr_conv);
return ret_val;
}
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
QueryChannelRange_set_first_blocknum(&this_ptr_conv, val);
}
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = QueryChannelRange_get_number_of_blocks(&this_ptr_conv);
return ret_val;
}
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
QueryChannelRange_set_number_of_blocks(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg) {
+ LDKQueryChannelRange ret_var = QueryChannelRange_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKQueryChannelRange arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = QueryChannelRange_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKQueryChannelRange orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKQueryChannelRange ret_var = QueryChannelRange_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKReplyChannelRange this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ReplyChannelRange_free(this_obj_conv);
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ReplyChannelRange_get_chain_hash(&this_ptr_conv));
return ret_arr;
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ReplyChannelRange_get_first_blocknum(&this_ptr_conv);
return ret_val;
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ReplyChannelRange_set_first_blocknum(&this_ptr_conv, val);
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ReplyChannelRange_get_number_of_blocks(&this_ptr_conv);
return ret_val;
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ReplyChannelRange_set_number_of_blocks(&this_ptr_conv, val);
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ReplyChannelRange_get_sync_complete(&this_ptr_conv);
return ret_val;
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ReplyChannelRange_set_sync_complete(&this_ptr_conv, val);
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u64Z val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg) {
+ LDKReplyChannelRange ret_var = ReplyChannelRange_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKReplyChannelRange arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ReplyChannelRange_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKReplyChannelRange orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKReplyChannelRange ret_var = ReplyChannelRange_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKQueryShortChannelIds this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
QueryShortChannelIds_free(this_obj_conv);
}
LDKQueryShortChannelIds this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *QueryShortChannelIds_get_chain_hash(&this_ptr_conv));
return ret_arr;
LDKQueryShortChannelIds this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKQueryShortChannelIds this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u64Z val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg) {
+ LDKQueryShortChannelIds ret_var = QueryShortChannelIds_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_QueryShortChannelIds_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKQueryShortChannelIds arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = QueryShortChannelIds_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_QueryShortChannelIds_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKQueryShortChannelIds orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKQueryShortChannelIds ret_var = QueryShortChannelIds_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKReplyShortChannelIdsEnd this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ReplyShortChannelIdsEnd_free(this_obj_conv);
}
LDKReplyShortChannelIdsEnd this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ReplyShortChannelIdsEnd_get_chain_hash(&this_ptr_conv));
return ret_arr;
LDKReplyShortChannelIdsEnd this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKReplyShortChannelIdsEnd this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ReplyShortChannelIdsEnd_get_full_information(&this_ptr_conv);
return ret_val;
}
LDKReplyShortChannelIdsEnd this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ReplyShortChannelIdsEnd_set_full_information(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg) {
+ LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKReplyShortChannelIdsEnd arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ReplyShortChannelIdsEnd_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKReplyShortChannelIdsEnd orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKGossipTimestampFilter this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
GossipTimestampFilter_free(this_obj_conv);
}
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *GossipTimestampFilter_get_chain_hash(&this_ptr_conv));
return ret_arr;
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = GossipTimestampFilter_get_first_timestamp(&this_ptr_conv);
return ret_val;
}
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
GossipTimestampFilter_set_first_timestamp(&this_ptr_conv, val);
}
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = GossipTimestampFilter_get_timestamp_range(&this_ptr_conv);
return ret_val;
}
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
GossipTimestampFilter_set_timestamp_range(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg) {
+ LDKGossipTimestampFilter ret_var = GossipTimestampFilter_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKGossipTimestampFilter arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = GossipTimestampFilter_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKGossipTimestampFilter orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKGossipTimestampFilter ret_var = GossipTimestampFilter_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
ErrorAction_free(this_ptr_conv);
}
+static inline uint64_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg) {
+ LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
+ *ret_copy = ErrorAction_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErrorAction_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKErrorAction* arg_conv = (LDKErrorAction*)arg;
+ int64_t ret_val = ErrorAction_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErrorAction_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKErrorAction* orig_conv = (LDKErrorAction*)orig;
LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
LDKErrorMessage msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ErrorMessage_clone(&msg_conv);
LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
*ret_copy = ErrorAction_disconnect_peer(msg_conv);
LDKErrorMessage msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ErrorMessage_clone(&msg_conv);
LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
*ret_copy = ErrorAction_send_error_message(msg_conv);
LDKLightningError this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
LightningError_free(this_obj_conv);
}
LDKLightningError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr ret_str = LightningError_get_err(&this_ptr_conv);
jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
Str_free(ret_str);
LDKLightningError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr val_conv = java_to_owned_str(env, val);
LightningError_set_err(&this_ptr_conv, val_conv);
}
LDKLightningError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
*ret_copy = LightningError_get_action(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKLightningError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKErrorAction val_conv = *(LDKErrorAction*)(val_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg) {
+ LDKLightningError ret_var = LightningError_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LightningError_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKLightningError arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = LightningError_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LightningError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKLightningError orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKLightningError ret_var = LightningError_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentUpdate this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
CommitmentUpdate_free(this_obj_conv);
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateAddHTLCZ ret_var = CommitmentUpdate_get_update_add_htlcs(&this_ptr_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_15_ref = 0;
CHECK((((uint64_t)ret_conv_15_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_15_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_15_var);
ret_conv_15_ref = (uint64_t)ret_conv_15_var.inner;
if (ret_conv_15_var.is_owned) {
ret_conv_15_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateAddHTLCZ val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
LDKUpdateAddHTLC val_conv_15_conv;
val_conv_15_conv.inner = (void*)(val_conv_15 & (~1));
val_conv_15_conv.is_owned = (val_conv_15 & 1) || (val_conv_15 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_15_conv);
val_conv_15_conv = UpdateAddHTLC_clone(&val_conv_15_conv);
val_constr.data[p] = val_conv_15_conv;
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFulfillHTLCZ ret_var = CommitmentUpdate_get_update_fulfill_htlcs(&this_ptr_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_19_ref = 0;
CHECK((((uint64_t)ret_conv_19_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_19_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_19_var);
ret_conv_19_ref = (uint64_t)ret_conv_19_var.inner;
if (ret_conv_19_var.is_owned) {
ret_conv_19_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFulfillHTLCZ val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
LDKUpdateFulfillHTLC val_conv_19_conv;
val_conv_19_conv.inner = (void*)(val_conv_19 & (~1));
val_conv_19_conv.is_owned = (val_conv_19 & 1) || (val_conv_19 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_19_conv);
val_conv_19_conv = UpdateFulfillHTLC_clone(&val_conv_19_conv);
val_constr.data[t] = val_conv_19_conv;
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFailHTLCZ ret_var = CommitmentUpdate_get_update_fail_htlcs(&this_ptr_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_16_ref = 0;
CHECK((((uint64_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
ret_conv_16_ref = (uint64_t)ret_conv_16_var.inner;
if (ret_conv_16_var.is_owned) {
ret_conv_16_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFailHTLCZ val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
LDKUpdateFailHTLC val_conv_16_conv;
val_conv_16_conv.inner = (void*)(val_conv_16 & (~1));
val_conv_16_conv.is_owned = (val_conv_16 & 1) || (val_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_16_conv);
val_conv_16_conv = UpdateFailHTLC_clone(&val_conv_16_conv);
val_constr.data[q] = val_conv_16_conv;
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFailMalformedHTLCZ ret_var = CommitmentUpdate_get_update_fail_malformed_htlcs(&this_ptr_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_25_ref = 0;
CHECK((((uint64_t)ret_conv_25_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_25_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_25_var);
ret_conv_25_ref = (uint64_t)ret_conv_25_var.inner;
if (ret_conv_25_var.is_owned) {
ret_conv_25_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFailMalformedHTLCZ val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
LDKUpdateFailMalformedHTLC val_conv_25_conv;
val_conv_25_conv.inner = (void*)(val_conv_25 & (~1));
val_conv_25_conv.is_owned = (val_conv_25 & 1) || (val_conv_25 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_25_conv);
val_conv_25_conv = UpdateFailMalformedHTLC_clone(&val_conv_25_conv);
val_constr.data[z] = val_conv_25_conv;
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUpdateFee ret_var = CommitmentUpdate_get_update_fee(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUpdateFee val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = UpdateFee_clone(&val_conv);
CommitmentUpdate_set_update_fee(&this_ptr_conv, val_conv);
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCommitmentSigned ret_var = CommitmentUpdate_get_commitment_signed(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCommitmentSigned val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = CommitmentSigned_clone(&val_conv);
CommitmentUpdate_set_commitment_signed(&this_ptr_conv, val_conv);
}
LDKUpdateAddHTLC update_add_htlcs_arg_conv_15_conv;
update_add_htlcs_arg_conv_15_conv.inner = (void*)(update_add_htlcs_arg_conv_15 & (~1));
update_add_htlcs_arg_conv_15_conv.is_owned = (update_add_htlcs_arg_conv_15 & 1) || (update_add_htlcs_arg_conv_15 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_add_htlcs_arg_conv_15_conv);
update_add_htlcs_arg_conv_15_conv = UpdateAddHTLC_clone(&update_add_htlcs_arg_conv_15_conv);
update_add_htlcs_arg_constr.data[p] = update_add_htlcs_arg_conv_15_conv;
}
LDKUpdateFulfillHTLC update_fulfill_htlcs_arg_conv_19_conv;
update_fulfill_htlcs_arg_conv_19_conv.inner = (void*)(update_fulfill_htlcs_arg_conv_19 & (~1));
update_fulfill_htlcs_arg_conv_19_conv.is_owned = (update_fulfill_htlcs_arg_conv_19 & 1) || (update_fulfill_htlcs_arg_conv_19 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fulfill_htlcs_arg_conv_19_conv);
update_fulfill_htlcs_arg_conv_19_conv = UpdateFulfillHTLC_clone(&update_fulfill_htlcs_arg_conv_19_conv);
update_fulfill_htlcs_arg_constr.data[t] = update_fulfill_htlcs_arg_conv_19_conv;
}
LDKUpdateFailHTLC update_fail_htlcs_arg_conv_16_conv;
update_fail_htlcs_arg_conv_16_conv.inner = (void*)(update_fail_htlcs_arg_conv_16 & (~1));
update_fail_htlcs_arg_conv_16_conv.is_owned = (update_fail_htlcs_arg_conv_16 & 1) || (update_fail_htlcs_arg_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fail_htlcs_arg_conv_16_conv);
update_fail_htlcs_arg_conv_16_conv = UpdateFailHTLC_clone(&update_fail_htlcs_arg_conv_16_conv);
update_fail_htlcs_arg_constr.data[q] = update_fail_htlcs_arg_conv_16_conv;
}
LDKUpdateFailMalformedHTLC update_fail_malformed_htlcs_arg_conv_25_conv;
update_fail_malformed_htlcs_arg_conv_25_conv.inner = (void*)(update_fail_malformed_htlcs_arg_conv_25 & (~1));
update_fail_malformed_htlcs_arg_conv_25_conv.is_owned = (update_fail_malformed_htlcs_arg_conv_25 & 1) || (update_fail_malformed_htlcs_arg_conv_25 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fail_malformed_htlcs_arg_conv_25_conv);
update_fail_malformed_htlcs_arg_conv_25_conv = UpdateFailMalformedHTLC_clone(&update_fail_malformed_htlcs_arg_conv_25_conv);
update_fail_malformed_htlcs_arg_constr.data[z] = update_fail_malformed_htlcs_arg_conv_25_conv;
}
LDKUpdateFee update_fee_arg_conv;
update_fee_arg_conv.inner = (void*)(update_fee_arg & (~1));
update_fee_arg_conv.is_owned = (update_fee_arg & 1) || (update_fee_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fee_arg_conv);
update_fee_arg_conv = UpdateFee_clone(&update_fee_arg_conv);
LDKCommitmentSigned commitment_signed_arg_conv;
commitment_signed_arg_conv.inner = (void*)(commitment_signed_arg & (~1));
commitment_signed_arg_conv.is_owned = (commitment_signed_arg & 1) || (commitment_signed_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_signed_arg_conv);
commitment_signed_arg_conv = CommitmentSigned_clone(&commitment_signed_arg_conv);
LDKCommitmentUpdate ret_var = CommitmentUpdate_new(update_add_htlcs_arg_constr, update_fulfill_htlcs_arg_constr, update_fail_htlcs_arg_constr, update_fail_malformed_htlcs_arg_constr, update_fee_arg_conv, commitment_signed_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg) {
+ LDKCommitmentUpdate ret_var = CommitmentUpdate_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCommitmentUpdate arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = CommitmentUpdate_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCommitmentUpdate orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKCommitmentUpdate ret_var = CommitmentUpdate_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKAcceptChannel obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = AcceptChannel_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKAnnouncementSignatures obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = AnnouncementSignatures_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKChannelReestablish obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelReestablish_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKClosingSigned obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ClosingSigned_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKClosingSignedFeeRange obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ClosingSignedFeeRange_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKCommitmentSigned obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = CommitmentSigned_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKFundingCreated obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = FundingCreated_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKFundingSigned obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = FundingSigned_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKFundingLocked obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = FundingLocked_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKInit obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Init_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKOpenChannel obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = OpenChannel_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKRevokeAndACK obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RevokeAndACK_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKShutdown obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Shutdown_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKUpdateFailHTLC obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UpdateFailHTLC_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKUpdateFailMalformedHTLC obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UpdateFailMalformedHTLC_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKUpdateFee obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UpdateFee_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKUpdateFulfillHTLC obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UpdateFulfillHTLC_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKUpdateAddHTLC obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UpdateAddHTLC_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKPing obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Ping_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKPong obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Pong_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKUnsignedChannelAnnouncement obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UnsignedChannelAnnouncement_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKChannelAnnouncement obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelAnnouncement_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKUnsignedChannelUpdate obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UnsignedChannelUpdate_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKChannelUpdate obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelUpdate_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKErrorMessage obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ErrorMessage_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKUnsignedNodeAnnouncement obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UnsignedNodeAnnouncement_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKNodeAnnouncement obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NodeAnnouncement_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKQueryShortChannelIds obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = QueryShortChannelIds_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKReplyShortChannelIdsEnd obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ReplyShortChannelIdsEnd_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKQueryChannelRange this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int32_t ret_val = QueryChannelRange_end_blocknum(&this_arg_conv);
return ret_val;
}
LDKQueryChannelRange obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = QueryChannelRange_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKReplyChannelRange obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ReplyChannelRange_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKGossipTimestampFilter obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = GossipTimestampFilter_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKIgnoringMessageHandler this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
IgnoringMessageHandler_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKIgnoringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
*ret_ret = IgnoringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKIgnoringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRoutingMessageHandler* ret_ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
*ret_ret = IgnoringMessageHandler_as_RoutingMessageHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKIgnoringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCustomMessageReader* ret_ret = MALLOC(sizeof(LDKCustomMessageReader), "LDKCustomMessageReader");
*ret_ret = IgnoringMessageHandler_as_CustomMessageReader(&this_arg_conv);
return (uint64_t)ret_ret;
LDKIgnoringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCustomMessageHandler* ret_ret = MALLOC(sizeof(LDKCustomMessageHandler), "LDKCustomMessageHandler");
*ret_ret = IgnoringMessageHandler_as_CustomMessageHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKErroringMessageHandler this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ErroringMessageHandler_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKErroringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
*ret_ret = ErroringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKErroringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelMessageHandler* ret_ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
*ret_ret = ErroringMessageHandler_as_ChannelMessageHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKMessageHandler this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
MessageHandler_free(this_obj_conv);
}
LDKMessageHandler this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)MessageHandler_get_chan_handler(&this_ptr_conv)) | 1;
return ret_ret;
LDKMessageHandler this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKChannelMessageHandler val_conv = *(LDKChannelMessageHandler*)(val_ptr);
LDKMessageHandler this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)MessageHandler_get_route_handler(&this_ptr_conv)) | 1;
return ret_ret;
LDKMessageHandler this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKRoutingMessageHandler val_conv = *(LDKRoutingMessageHandler*)(val_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg) {
+ LDKSocketDescriptor* ret_ret = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
+ *ret_ret = SocketDescriptor_clone(arg);
+ return (uint64_t)ret_ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SocketDescriptor_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ void* arg_ptr = (void*)(((uint64_t)arg) & ~1);
+ if (!(arg & 1)) { CHECK_ACCESS(arg_ptr); }
+ LDKSocketDescriptor* arg_conv = (LDKSocketDescriptor*)arg_ptr;
+ int64_t ret_val = SocketDescriptor_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SocketDescriptor_1clone(JNIEnv *env, jclass clz, int64_t orig) {
void* orig_ptr = (void*)(((uint64_t)orig) & ~1);
if (!(orig & 1)) { CHECK_ACCESS(orig_ptr); }
LDKPeerHandleError this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
PeerHandleError_free(this_obj_conv);
}
LDKPeerHandleError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = PeerHandleError_get_no_connection_possible(&this_ptr_conv);
return ret_val;
}
LDKPeerHandleError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
PeerHandleError_set_no_connection_possible(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg) {
+ LDKPeerHandleError ret_var = PeerHandleError_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PeerHandleError_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKPeerHandleError arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = PeerHandleError_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PeerHandleError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKPeerHandleError orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPeerHandleError ret_var = PeerHandleError_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPeerManager this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
PeerManager_free(this_obj_conv);
}
LDKMessageHandler message_handler_conv;
message_handler_conv.inner = (void*)(message_handler & (~1));
message_handler_conv.is_owned = (message_handler & 1) || (message_handler == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(message_handler_conv);
// Warning: we need a move here but no clone is available for LDKMessageHandler
LDKSecretKey our_node_secret_ref;
CHECK((*env)->GetArrayLength(env, our_node_secret) == 32);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_PublicKeyZ ret_var = PeerManager_get_peer_node_ids(&this_arg_conv);
jobjectArray ret_arr = NULL;
ret_arr = (*env)->NewObjectArray(env, ret_var.datalen, arr_of_B_clz, NULL);
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPublicKey their_node_id_ref;
CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
(*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* descriptor_ptr = (void*)(((uint64_t)descriptor) & ~1);
CHECK_ACCESS(descriptor_ptr);
LDKSocketDescriptor descriptor_conv = *(LDKSocketDescriptor*)(descriptor_ptr);
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* descriptor_ptr = (void*)(((uint64_t)descriptor) & ~1);
if (!(descriptor & 1)) { CHECK_ACCESS(descriptor_ptr); }
LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)descriptor_ptr;
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* peer_descriptor_ptr = (void*)(((uint64_t)peer_descriptor) & ~1);
if (!(peer_descriptor & 1)) { CHECK_ACCESS(peer_descriptor_ptr); }
LDKSocketDescriptor* peer_descriptor_conv = (LDKSocketDescriptor*)peer_descriptor_ptr;
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
PeerManager_process_events(&this_arg_conv);
}
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* descriptor_ptr = (void*)(((uint64_t)descriptor) & ~1);
if (!(descriptor & 1)) { CHECK_ACCESS(descriptor_ptr); }
LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)descriptor_ptr;
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPublicKey node_id_ref;
CHECK((*env)->GetArrayLength(env, node_id) == 33);
(*env)->GetByteArrayRegion(env, node_id, 0, 33, node_id_ref.compressed_form);
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
PeerManager_disconnect_all_peers(&this_arg_conv);
}
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
PeerManager_timer_tick_occurred(&this_arg_conv);
}
LDKOutPoint funding_outpoint_conv;
funding_outpoint_conv.inner = (void*)(funding_outpoint & (~1));
funding_outpoint_conv.is_owned = (funding_outpoint & 1) || (funding_outpoint == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
LDKTransaction ret_var = build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script_ref, to_counterparty_script_ref, funding_outpoint_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
LDKTxCreationKeys this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
TxCreationKeys_free(this_obj_conv);
}
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, TxCreationKeys_get_per_commitment_point(&this_ptr_conv).compressed_form);
return ret_arr;
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, TxCreationKeys_get_revocation_key(&this_ptr_conv).compressed_form);
return ret_arr;
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, TxCreationKeys_get_broadcaster_htlc_key(&this_ptr_conv).compressed_form);
return ret_arr;
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, TxCreationKeys_get_countersignatory_htlc_key(&this_ptr_conv).compressed_form);
return ret_arr;
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, TxCreationKeys_get_broadcaster_delayed_payment_key(&this_ptr_conv).compressed_form);
return ret_arr;
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg) {
+ LDKTxCreationKeys ret_var = TxCreationKeys_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKTxCreationKeys arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = TxCreationKeys_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKTxCreationKeys orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKTxCreationKeys ret_var = TxCreationKeys_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKTxCreationKeys obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = TxCreationKeys_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKChannelPublicKeys this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelPublicKeys_free(this_obj_conv);
}
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelPublicKeys_get_funding_pubkey(&this_ptr_conv).compressed_form);
return ret_arr;
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelPublicKeys_get_revocation_basepoint(&this_ptr_conv).compressed_form);
return ret_arr;
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelPublicKeys_get_payment_point(&this_ptr_conv).compressed_form);
return ret_arr;
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelPublicKeys_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form);
return ret_arr;
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelPublicKeys_get_htlc_basepoint(&this_ptr_conv).compressed_form);
return ret_arr;
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg) {
+ LDKChannelPublicKeys ret_var = ChannelPublicKeys_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelPublicKeys arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelPublicKeys_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelPublicKeys orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelPublicKeys ret_var = ChannelPublicKeys_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelPublicKeys obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelPublicKeys_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKChannelPublicKeys broadcaster_keys_conv;
broadcaster_keys_conv.inner = (void*)(broadcaster_keys & (~1));
broadcaster_keys_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(broadcaster_keys_conv);
LDKChannelPublicKeys countersignatory_keys_conv;
countersignatory_keys_conv.inner = (void*)(countersignatory_keys & (~1));
countersignatory_keys_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(countersignatory_keys_conv);
LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
*ret_conv = TxCreationKeys_from_channel_static_keys(per_commitment_point_ref, &broadcaster_keys_conv, &countersignatory_keys_conv);
return (uint64_t)ret_conv;
LDKHTLCOutputInCommitment this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
HTLCOutputInCommitment_free(this_obj_conv);
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = HTLCOutputInCommitment_get_offered(&this_ptr_conv);
return ret_val;
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
HTLCOutputInCommitment_set_offered(&this_ptr_conv, val);
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = HTLCOutputInCommitment_get_amount_msat(&this_ptr_conv);
return ret_val;
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
HTLCOutputInCommitment_set_amount_msat(&this_ptr_conv, val);
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = HTLCOutputInCommitment_get_cltv_expiry(&this_ptr_conv);
return ret_val;
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
HTLCOutputInCommitment_set_cltv_expiry(&this_ptr_conv, val);
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *HTLCOutputInCommitment_get_payment_hash(&this_ptr_conv));
return ret_arr;
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
*ret_copy = HTLCOutputInCommitment_get_transaction_output_index(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg) {
+ LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKHTLCOutputInCommitment arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = HTLCOutputInCommitment_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKHTLCOutputInCommitment orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKHTLCOutputInCommitment obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = HTLCOutputInCommitment_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKHTLCOutputInCommitment htlc_conv;
htlc_conv.inner = (void*)(htlc & (~1));
htlc_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
LDKTxCreationKeys keys_conv;
keys_conv.inner = (void*)(keys & (~1));
keys_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(keys_conv);
LDKCVec_u8Z ret_var = get_htlc_redeemscript(&htlc_conv, &keys_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKHTLCOutputInCommitment htlc_conv;
htlc_conv.inner = (void*)(htlc & (~1));
htlc_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
LDKPublicKey broadcaster_delayed_payment_key_ref;
CHECK((*env)->GetArrayLength(env, broadcaster_delayed_payment_key) == 33);
(*env)->GetByteArrayRegion(env, broadcaster_delayed_payment_key, 0, 33, broadcaster_delayed_payment_key_ref.compressed_form);
LDKChannelTransactionParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelTransactionParameters_free(this_obj_conv);
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelPublicKeys ret_var = ChannelTransactionParameters_get_holder_pubkeys(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelPublicKeys val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelPublicKeys_clone(&val_conv);
ChannelTransactionParameters_set_holder_pubkeys(&this_ptr_conv, val_conv);
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = ChannelTransactionParameters_get_holder_selected_contest_delay(&this_ptr_conv);
return ret_val;
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelTransactionParameters_set_holder_selected_contest_delay(&this_ptr_conv, val);
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelTransactionParameters_get_is_outbound_from_holder(&this_ptr_conv);
return ret_val;
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelTransactionParameters_set_is_outbound_from_holder(&this_ptr_conv, val);
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCounterpartyChannelTransactionParameters ret_var = ChannelTransactionParameters_get_counterparty_parameters(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCounterpartyChannelTransactionParameters val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = CounterpartyChannelTransactionParameters_clone(&val_conv);
ChannelTransactionParameters_set_counterparty_parameters(&this_ptr_conv, val_conv);
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint ret_var = ChannelTransactionParameters_get_funding_outpoint(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = OutPoint_clone(&val_conv);
ChannelTransactionParameters_set_funding_outpoint(&this_ptr_conv, val_conv);
}
LDKChannelPublicKeys holder_pubkeys_arg_conv;
holder_pubkeys_arg_conv.inner = (void*)(holder_pubkeys_arg & (~1));
holder_pubkeys_arg_conv.is_owned = (holder_pubkeys_arg & 1) || (holder_pubkeys_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_pubkeys_arg_conv);
holder_pubkeys_arg_conv = ChannelPublicKeys_clone(&holder_pubkeys_arg_conv);
LDKCounterpartyChannelTransactionParameters counterparty_parameters_arg_conv;
counterparty_parameters_arg_conv.inner = (void*)(counterparty_parameters_arg & (~1));
counterparty_parameters_arg_conv.is_owned = (counterparty_parameters_arg & 1) || (counterparty_parameters_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(counterparty_parameters_arg_conv);
counterparty_parameters_arg_conv = CounterpartyChannelTransactionParameters_clone(&counterparty_parameters_arg_conv);
LDKOutPoint funding_outpoint_arg_conv;
funding_outpoint_arg_conv.inner = (void*)(funding_outpoint_arg & (~1));
funding_outpoint_arg_conv.is_owned = (funding_outpoint_arg & 1) || (funding_outpoint_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_arg_conv);
funding_outpoint_arg_conv = OutPoint_clone(&funding_outpoint_arg_conv);
LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_new(holder_pubkeys_arg_conv, holder_selected_contest_delay_arg, is_outbound_from_holder_arg, counterparty_parameters_arg_conv, funding_outpoint_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg) {
+ LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelTransactionParameters arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelTransactionParameters_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelTransactionParameters orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCounterpartyChannelTransactionParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
CounterpartyChannelTransactionParameters_free(this_obj_conv);
}
LDKCounterpartyChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelPublicKeys ret_var = CounterpartyChannelTransactionParameters_get_pubkeys(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCounterpartyChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelPublicKeys val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelPublicKeys_clone(&val_conv);
CounterpartyChannelTransactionParameters_set_pubkeys(&this_ptr_conv, val_conv);
}
LDKCounterpartyChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = CounterpartyChannelTransactionParameters_get_selected_contest_delay(&this_ptr_conv);
return ret_val;
}
LDKCounterpartyChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
CounterpartyChannelTransactionParameters_set_selected_contest_delay(&this_ptr_conv, val);
}
LDKChannelPublicKeys pubkeys_arg_conv;
pubkeys_arg_conv.inner = (void*)(pubkeys_arg & (~1));
pubkeys_arg_conv.is_owned = (pubkeys_arg & 1) || (pubkeys_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_arg_conv);
pubkeys_arg_conv = ChannelPublicKeys_clone(&pubkeys_arg_conv);
LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_new(pubkeys_arg_conv, selected_contest_delay_arg);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg) {
+ LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCounterpartyChannelTransactionParameters arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = CounterpartyChannelTransactionParameters_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCounterpartyChannelTransactionParameters orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = ChannelTransactionParameters_is_populated(&this_arg_conv);
return ret_val;
}
LDKChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_holder_broadcastable(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_counterparty_broadcastable(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCounterpartyChannelTransactionParameters obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = CounterpartyChannelTransactionParameters_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKChannelTransactionParameters obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelTransactionParameters_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKDirectedChannelTransactionParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DirectedChannelTransactionParameters_free(this_obj_conv);
}
LDKDirectedChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_broadcaster_pubkeys(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDirectedChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_countersignatory_pubkeys(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDirectedChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int16_t ret_val = DirectedChannelTransactionParameters_contest_delay(&this_arg_conv);
return ret_val;
}
LDKDirectedChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = DirectedChannelTransactionParameters_is_outbound(&this_arg_conv);
return ret_val;
}
LDKDirectedChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKOutPoint ret_var = DirectedChannelTransactionParameters_funding_outpoint(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKHolderCommitmentTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
HolderCommitmentTransaction_free(this_obj_conv);
}
LDKHolderCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, HolderCommitmentTransaction_get_counterparty_sig(&this_ptr_conv).compact_form);
return ret_arr;
LDKHolderCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
LDKHolderCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_SignatureZ val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
HolderCommitmentTransaction_set_counterparty_htlc_sigs(&this_ptr_conv, val_constr);
}
+static inline uint64_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg) {
+ LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HolderCommitmentTransaction_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKHolderCommitmentTransaction arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = HolderCommitmentTransaction_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HolderCommitmentTransaction_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKHolderCommitmentTransaction orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKHolderCommitmentTransaction obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = HolderCommitmentTransaction_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKCommitmentTransaction commitment_tx_conv;
commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
commitment_tx_conv.is_owned = (commitment_tx & 1) || (commitment_tx == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
commitment_tx_conv = CommitmentTransaction_clone(&commitment_tx_conv);
LDKSignature counterparty_sig_ref;
CHECK((*env)->GetArrayLength(env, counterparty_sig) == 64);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKBuiltCommitmentTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
BuiltCommitmentTransaction_free(this_obj_conv);
}
LDKBuiltCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKTransaction ret_var = BuiltCommitmentTransaction_get_transaction(&this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKBuiltCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKTransaction val_ref;
val_ref.datalen = (*env)->GetArrayLength(env, val);
val_ref.data = MALLOC(val_ref.datalen, "LDKTransaction Bytes");
LDKBuiltCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *BuiltCommitmentTransaction_get_txid(&this_ptr_conv));
return ret_arr;
LDKBuiltCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg) {
+ LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKBuiltCommitmentTransaction arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = BuiltCommitmentTransaction_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKBuiltCommitmentTransaction orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKBuiltCommitmentTransaction obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = BuiltCommitmentTransaction_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKBuiltCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKu8slice funding_redeemscript_ref;
funding_redeemscript_ref.datalen = (*env)->GetArrayLength(env, funding_redeemscript);
funding_redeemscript_ref.data = (*env)->GetByteArrayElements (env, funding_redeemscript, NULL);
LDKBuiltCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char funding_key_arr[32];
CHECK((*env)->GetArrayLength(env, funding_key) == 32);
(*env)->GetByteArrayRegion(env, funding_key, 0, 32, funding_key_arr);
LDKClosingTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ClosingTransaction_free(this_obj_conv);
}
+static inline uint64_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg) {
+ LDKClosingTransaction ret_var = ClosingTransaction_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosingTransaction_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKClosingTransaction arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ClosingTransaction_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosingTransaction_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKClosingTransaction orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKClosingTransaction ret_var = ClosingTransaction_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = ClosingTransaction_hash(&o_conv);
return ret_val;
}
LDKOutPoint funding_outpoint_conv;
funding_outpoint_conv.inner = (void*)(funding_outpoint & (~1));
funding_outpoint_conv.is_owned = (funding_outpoint & 1) || (funding_outpoint == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
LDKClosingTransaction ret_var = ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script_ref, to_counterparty_script_ref, funding_outpoint_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTrustedClosingTransaction ret_var = ClosingTransaction_trust(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKOutPoint funding_outpoint_conv;
funding_outpoint_conv.inner = (void*)(funding_outpoint & (~1));
funding_outpoint_conv.is_owned = (funding_outpoint & 1) || (funding_outpoint == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
*ret_conv = ClosingTransaction_verify(&this_arg_conv, funding_outpoint_conv);
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = ClosingTransaction_to_holder_value_sat(&this_arg_conv);
return ret_val;
}
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = ClosingTransaction_to_counterparty_value_sat(&this_arg_conv);
return ret_val;
}
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKu8slice ret_var = ClosingTransaction_to_holder_script(&this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKu8slice ret_var = ClosingTransaction_to_counterparty_script(&this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKTrustedClosingTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
TrustedClosingTransaction_free(this_obj_conv);
}
LDKTrustedClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTransaction ret_var = TrustedClosingTransaction_built_transaction(&this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKTrustedClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKu8slice funding_redeemscript_ref;
funding_redeemscript_ref.datalen = (*env)->GetArrayLength(env, funding_redeemscript);
funding_redeemscript_ref.data = (*env)->GetByteArrayElements (env, funding_redeemscript, NULL);
LDKTrustedClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char funding_key_arr[32];
CHECK((*env)->GetArrayLength(env, funding_key) == 32);
(*env)->GetByteArrayRegion(env, funding_key, 0, 32, funding_key_arr);
LDKCommitmentTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
CommitmentTransaction_free(this_obj_conv);
}
+static inline uint64_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg) {
+ LDKCommitmentTransaction ret_var = CommitmentTransaction_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCommitmentTransaction arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = CommitmentTransaction_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCommitmentTransaction orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKCommitmentTransaction ret_var = CommitmentTransaction_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentTransaction obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = CommitmentTransaction_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = CommitmentTransaction_commitment_number(&this_arg_conv);
return ret_val;
}
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = CommitmentTransaction_to_broadcaster_value_sat(&this_arg_conv);
return ret_val;
}
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = CommitmentTransaction_to_countersignatory_value_sat(&this_arg_conv);
return ret_val;
}
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int32_t ret_val = CommitmentTransaction_feerate_per_kw(&this_arg_conv);
return ret_val;
}
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTrustedCommitmentTransaction ret_var = CommitmentTransaction_trust(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKDirectedChannelTransactionParameters channel_parameters_conv;
channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
channel_parameters_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
LDKChannelPublicKeys broadcaster_keys_conv;
broadcaster_keys_conv.inner = (void*)(broadcaster_keys & (~1));
broadcaster_keys_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(broadcaster_keys_conv);
LDKChannelPublicKeys countersignatory_keys_conv;
countersignatory_keys_conv.inner = (void*)(countersignatory_keys & (~1));
countersignatory_keys_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(countersignatory_keys_conv);
LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
*ret_conv = CommitmentTransaction_verify(&this_arg_conv, &channel_parameters_conv, &broadcaster_keys_conv, &countersignatory_keys_conv);
return (uint64_t)ret_conv;
LDKTrustedCommitmentTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
TrustedCommitmentTransaction_free(this_obj_conv);
}
LDKTrustedCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, TrustedCommitmentTransaction_txid(&this_arg_conv).data);
return ret_arr;
LDKTrustedCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKBuiltCommitmentTransaction ret_var = TrustedCommitmentTransaction_built_transaction(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKTrustedCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTxCreationKeys ret_var = TrustedCommitmentTransaction_keys(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKTrustedCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char htlc_base_key_arr[32];
CHECK((*env)->GetArrayLength(env, htlc_base_key) == 32);
(*env)->GetByteArrayRegion(env, htlc_base_key, 0, 32, htlc_base_key_arr);
LDKDirectedChannelTransactionParameters channel_parameters_conv;
channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
channel_parameters_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
*ret_conv = TrustedCommitmentTransaction_get_htlc_sigs(&this_arg_conv, htlc_base_key_ref, &channel_parameters_conv);
return (uint64_t)ret_conv;
LDKInitFeatures a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKInitFeatures b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = InitFeatures_eq(&a_conv, &b_conv);
return ret_val;
}
LDKNodeFeatures a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKNodeFeatures b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = NodeFeatures_eq(&a_conv, &b_conv);
return ret_val;
}
LDKChannelFeatures a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKChannelFeatures b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = ChannelFeatures_eq(&a_conv, &b_conv);
return ret_val;
}
LDKInvoiceFeatures a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKInvoiceFeatures b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = InvoiceFeatures_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg) {
+ LDKInitFeatures ret_var = InitFeatures_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InitFeatures_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKInitFeatures arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = InitFeatures_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InitFeatures_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKInitFeatures orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInitFeatures ret_var = InitFeatures_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg) {
+ LDKNodeFeatures ret_var = NodeFeatures_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKNodeFeatures arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NodeFeatures_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKNodeFeatures orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNodeFeatures ret_var = NodeFeatures_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg) {
+ LDKChannelFeatures ret_var = ChannelFeatures_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelFeatures_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelFeatures arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelFeatures_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelFeatures_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelFeatures orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelFeatures ret_var = ChannelFeatures_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg) {
+ LDKInvoiceFeatures ret_var = InvoiceFeatures_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InvoiceFeatures_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKInvoiceFeatures arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = InvoiceFeatures_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InvoiceFeatures_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKInvoiceFeatures orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInvoiceFeatures ret_var = InvoiceFeatures_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInitFeatures this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InitFeatures_free(this_obj_conv);
}
LDKNodeFeatures this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NodeFeatures_free(this_obj_conv);
}
LDKChannelFeatures this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelFeatures_free(this_obj_conv);
}
LDKInvoiceFeatures this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InvoiceFeatures_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInitFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = InitFeatures_requires_unknown_bits(&this_arg_conv);
return ret_val;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = NodeFeatures_requires_unknown_bits(&this_arg_conv);
return ret_val;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = ChannelFeatures_requires_unknown_bits(&this_arg_conv);
return ret_val;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvoiceFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = InvoiceFeatures_requires_unknown_bits(&this_arg_conv);
return ret_val;
}
LDKInitFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = InitFeatures_supports_payment_secret(&this_arg_conv);
return ret_val;
}
LDKNodeFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = NodeFeatures_supports_payment_secret(&this_arg_conv);
return ret_val;
}
LDKInvoiceFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = InvoiceFeatures_supports_payment_secret(&this_arg_conv);
return ret_val;
}
LDKInitFeatures obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = InitFeatures_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKNodeFeatures obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NodeFeatures_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKChannelFeatures obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelFeatures_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKInvoiceFeatures obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = InvoiceFeatures_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKShutdownScript this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ShutdownScript_free(this_obj_conv);
}
+static inline uint64_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg) {
+ LDKShutdownScript ret_var = ShutdownScript_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ShutdownScript_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKShutdownScript arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ShutdownScript_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ShutdownScript_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKShutdownScript orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKShutdownScript ret_var = ShutdownScript_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvalidShutdownScript this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InvalidShutdownScript_free(this_obj_conv);
}
LDKInvalidShutdownScript this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKu8slice ret_var = InvalidShutdownScript_get_script(&this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKInvalidShutdownScript this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u8Z val_ref;
val_ref.datalen = (*env)->GetArrayLength(env, val);
val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg) {
+ LDKInvalidShutdownScript ret_var = InvalidShutdownScript_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InvalidShutdownScript_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKInvalidShutdownScript arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = InvalidShutdownScript_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InvalidShutdownScript_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKInvalidShutdownScript orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInvalidShutdownScript ret_var = InvalidShutdownScript_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKShutdownScript obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ShutdownScript_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKShutdownScript this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
this_arg_conv = ShutdownScript_clone(&this_arg_conv);
LDKCVec_u8Z ret_var = ShutdownScript_into_inner(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
LDKShutdownScript this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ShutdownScript_as_legacy_pubkey(&this_arg_conv).compressed_form);
return ret_arr;
LDKShutdownScript this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInitFeatures features_conv;
features_conv.inner = (void*)(features & (~1));
features_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_conv);
jboolean ret_val = ShutdownScript_is_compatible(&this_arg_conv, &features_conv);
return ret_val;
}
CustomMessageReader_free(this_ptr_conv);
}
+static inline uint64_t Type_clone_ptr(LDKType *NONNULL_PTR arg) {
+ LDKType* ret_ret = MALLOC(sizeof(LDKType), "LDKType");
+ *ret_ret = Type_clone(arg);
+ return (uint64_t)ret_ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Type_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ void* arg_ptr = (void*)(((uint64_t)arg) & ~1);
+ if (!(arg & 1)) { CHECK_ACCESS(arg_ptr); }
+ LDKType* arg_conv = (LDKType*)arg_ptr;
+ int64_t ret_val = Type_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Type_1clone(JNIEnv *env, jclass clz, int64_t orig) {
void* orig_ptr = (void*)(((uint64_t)orig) & ~1);
if (!(orig & 1)) { CHECK_ACCESS(orig_ptr); }
LDKLockableScore this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
LockableScore_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKLockableScore obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = LockableScore_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKNodeId this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NodeId_free(this_obj_conv);
}
+static inline uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg) {
+ LDKNodeId ret_var = NodeId_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeId_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKNodeId arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NodeId_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeId_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKNodeId orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNodeId ret_var = NodeId_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeId this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKu8slice ret_var = NodeId_as_slice(&this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKNodeId o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = NodeId_hash(&o_conv);
return ret_val;
}
LDKNodeId obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NodeId_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKNetworkGraph this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NetworkGraph_free(this_obj_conv);
}
+static inline uint64_t NetworkGraph_clone_ptr(LDKNetworkGraph *NONNULL_PTR arg) {
+ LDKNetworkGraph ret_var = NetworkGraph_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKNetworkGraph arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NetworkGraph_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKNetworkGraph orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNetworkGraph ret_var = NetworkGraph_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKReadOnlyNetworkGraph this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ReadOnlyNetworkGraph_free(this_obj_conv);
}
NetworkUpdate_free(this_ptr_conv);
}
+static inline uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg) {
+ LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
+ *ret_copy = NetworkUpdate_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkUpdate_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKNetworkUpdate* arg_conv = (LDKNetworkUpdate*)arg;
+ int64_t ret_val = NetworkUpdate_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKNetworkUpdate* orig_conv = (LDKNetworkUpdate*)orig;
LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ChannelUpdate_clone(&msg_conv);
LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
*ret_copy = NetworkUpdate_channel_update_message(msg_conv);
return ret_arr;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkUpdate_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = (*env)->GetArrayLength(env, ser);
+ ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = NetworkUpdate_read(ser_ref);
+ (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
+ return (uint64_t)ret_conv;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetGraphMsgHandler_1as_1EventHandler(JNIEnv *env, jclass clz, int64_t this_arg) {
LDKNetGraphMsgHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKEventHandler* ret_ret = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
*ret_ret = NetGraphMsgHandler_as_EventHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKNetGraphMsgHandler this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NetGraphMsgHandler_free(this_obj_conv);
}
LDKNetworkGraph network_graph_conv;
network_graph_conv.inner = (void*)(network_graph & (~1));
network_graph_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
void* chain_access_ptr = (void*)(((uint64_t)chain_access) & ~1);
CHECK_ACCESS(chain_access_ptr);
LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNetGraphMsgHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* chain_access_ptr = (void*)(((uint64_t)chain_access) & ~1);
CHECK_ACCESS(chain_access_ptr);
LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
LDKNetGraphMsgHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRoutingMessageHandler* ret_ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
*ret_ret = NetGraphMsgHandler_as_RoutingMessageHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKNetGraphMsgHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
*ret_ret = NetGraphMsgHandler_as_MessageSendEventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKDirectionalChannelInfo this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DirectionalChannelInfo_free(this_obj_conv);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = DirectionalChannelInfo_get_last_update(&this_ptr_conv);
return ret_val;
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DirectionalChannelInfo_set_last_update(&this_ptr_conv, val);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = DirectionalChannelInfo_get_enabled(&this_ptr_conv);
return ret_val;
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DirectionalChannelInfo_set_enabled(&this_ptr_conv, val);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = DirectionalChannelInfo_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DirectionalChannelInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = DirectionalChannelInfo_get_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DirectionalChannelInfo_set_htlc_minimum_msat(&this_ptr_conv, val);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = DirectionalChannelInfo_get_htlc_maximum_msat(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees ret_var = DirectionalChannelInfo_get_fees(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = RoutingFees_clone(&val_conv);
DirectionalChannelInfo_set_fees(&this_ptr_conv, val_conv);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelUpdate ret_var = DirectionalChannelInfo_get_last_update_message(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelUpdate val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelUpdate_clone(&val_conv);
DirectionalChannelInfo_set_last_update_message(&this_ptr_conv, val_conv);
}
LDKRoutingFees fees_arg_conv;
fees_arg_conv.inner = (void*)(fees_arg & (~1));
fees_arg_conv.is_owned = (fees_arg & 1) || (fees_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(fees_arg_conv);
fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
LDKChannelUpdate last_update_message_arg_conv;
last_update_message_arg_conv.inner = (void*)(last_update_message_arg & (~1));
last_update_message_arg_conv.is_owned = (last_update_message_arg & 1) || (last_update_message_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(last_update_message_arg_conv);
last_update_message_arg_conv = ChannelUpdate_clone(&last_update_message_arg_conv);
LDKDirectionalChannelInfo ret_var = DirectionalChannelInfo_new(last_update_arg, enabled_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg_conv, fees_arg_conv, last_update_message_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t DirectionalChannelInfo_clone_ptr(LDKDirectionalChannelInfo *NONNULL_PTR arg) {
+ LDKDirectionalChannelInfo ret_var = DirectionalChannelInfo_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKDirectionalChannelInfo arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = DirectionalChannelInfo_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKDirectionalChannelInfo orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKDirectionalChannelInfo ret_var = DirectionalChannelInfo_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDirectionalChannelInfo obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = DirectionalChannelInfo_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKChannelInfo this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelInfo_free(this_obj_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures ret_var = ChannelInfo_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelFeatures_clone(&val_conv);
ChannelInfo_set_features(&this_ptr_conv, val_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeId ret_var = ChannelInfo_get_node_one(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeId val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeId_clone(&val_conv);
ChannelInfo_set_node_one(&this_ptr_conv, val_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKDirectionalChannelInfo ret_var = ChannelInfo_get_one_to_two(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKDirectionalChannelInfo val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = DirectionalChannelInfo_clone(&val_conv);
ChannelInfo_set_one_to_two(&this_ptr_conv, val_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeId ret_var = ChannelInfo_get_node_two(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeId val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeId_clone(&val_conv);
ChannelInfo_set_node_two(&this_ptr_conv, val_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKDirectionalChannelInfo ret_var = ChannelInfo_get_two_to_one(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKDirectionalChannelInfo val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = DirectionalChannelInfo_clone(&val_conv);
ChannelInfo_set_two_to_one(&this_ptr_conv, val_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = ChannelInfo_get_capacity_sats(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelAnnouncement ret_var = ChannelInfo_get_announcement_message(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelAnnouncement val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelAnnouncement_clone(&val_conv);
ChannelInfo_set_announcement_message(&this_ptr_conv, val_conv);
}
LDKChannelFeatures features_arg_conv;
features_arg_conv.inner = (void*)(features_arg & (~1));
features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
features_arg_conv = ChannelFeatures_clone(&features_arg_conv);
LDKNodeId node_one_arg_conv;
node_one_arg_conv.inner = (void*)(node_one_arg & (~1));
node_one_arg_conv.is_owned = (node_one_arg & 1) || (node_one_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(node_one_arg_conv);
node_one_arg_conv = NodeId_clone(&node_one_arg_conv);
LDKDirectionalChannelInfo one_to_two_arg_conv;
one_to_two_arg_conv.inner = (void*)(one_to_two_arg & (~1));
one_to_two_arg_conv.is_owned = (one_to_two_arg & 1) || (one_to_two_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(one_to_two_arg_conv);
one_to_two_arg_conv = DirectionalChannelInfo_clone(&one_to_two_arg_conv);
LDKNodeId node_two_arg_conv;
node_two_arg_conv.inner = (void*)(node_two_arg & (~1));
node_two_arg_conv.is_owned = (node_two_arg & 1) || (node_two_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(node_two_arg_conv);
node_two_arg_conv = NodeId_clone(&node_two_arg_conv);
LDKDirectionalChannelInfo two_to_one_arg_conv;
two_to_one_arg_conv.inner = (void*)(two_to_one_arg & (~1));
two_to_one_arg_conv.is_owned = (two_to_one_arg & 1) || (two_to_one_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(two_to_one_arg_conv);
two_to_one_arg_conv = DirectionalChannelInfo_clone(&two_to_one_arg_conv);
void* capacity_sats_arg_ptr = (void*)(((uint64_t)capacity_sats_arg) & ~1);
CHECK_ACCESS(capacity_sats_arg_ptr);
LDKChannelAnnouncement announcement_message_arg_conv;
announcement_message_arg_conv.inner = (void*)(announcement_message_arg & (~1));
announcement_message_arg_conv.is_owned = (announcement_message_arg & 1) || (announcement_message_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(announcement_message_arg_conv);
announcement_message_arg_conv = ChannelAnnouncement_clone(&announcement_message_arg_conv);
LDKChannelInfo ret_var = ChannelInfo_new(features_arg_conv, node_one_arg_conv, one_to_two_arg_conv, node_two_arg_conv, two_to_one_arg_conv, capacity_sats_arg_conv, announcement_message_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg) {
+ LDKChannelInfo ret_var = ChannelInfo_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelInfo arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelInfo_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelInfo orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelInfo ret_var = ChannelInfo_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelInfo_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKRoutingFees this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RoutingFees_free(this_obj_conv);
}
LDKRoutingFees this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = RoutingFees_get_base_msat(&this_ptr_conv);
return ret_val;
}
LDKRoutingFees this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RoutingFees_set_base_msat(&this_ptr_conv, val);
}
LDKRoutingFees this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = RoutingFees_get_proportional_millionths(&this_ptr_conv);
return ret_val;
}
LDKRoutingFees this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RoutingFees_set_proportional_millionths(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRoutingFees a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRoutingFees b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RoutingFees_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg) {
+ LDKRoutingFees ret_var = RoutingFees_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingFees_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKRoutingFees arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RoutingFees_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingFees_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKRoutingFees orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRoutingFees ret_var = RoutingFees_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRoutingFees o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = RoutingFees_hash(&o_conv);
return ret_val;
}
LDKRoutingFees obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RoutingFees_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKNodeAnnouncementInfo this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NodeAnnouncementInfo_free(this_obj_conv);
}
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures ret_var = NodeAnnouncementInfo_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeFeatures_clone(&val_conv);
NodeAnnouncementInfo_set_features(&this_ptr_conv, val_conv);
}
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = NodeAnnouncementInfo_get_last_update(&this_ptr_conv);
return ret_val;
}
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
NodeAnnouncementInfo_set_last_update(&this_ptr_conv, val);
}
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 3);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 3, *NodeAnnouncementInfo_get_rgb(&this_ptr_conv));
return ret_arr;
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThreeBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 3);
(*env)->GetByteArrayRegion(env, val, 0, 3, val_ref.data);
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *NodeAnnouncementInfo_get_alias(&this_ptr_conv));
return ret_arr;
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_NetAddressZ val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeAnnouncement ret_var = NodeAnnouncementInfo_get_announcement_message(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeAnnouncement val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeAnnouncement_clone(&val_conv);
NodeAnnouncementInfo_set_announcement_message(&this_ptr_conv, val_conv);
}
LDKNodeFeatures features_arg_conv;
features_arg_conv.inner = (void*)(features_arg & (~1));
features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
features_arg_conv = NodeFeatures_clone(&features_arg_conv);
LDKThreeBytes rgb_arg_ref;
CHECK((*env)->GetArrayLength(env, rgb_arg) == 3);
LDKNodeAnnouncement announcement_message_arg_conv;
announcement_message_arg_conv.inner = (void*)(announcement_message_arg & (~1));
announcement_message_arg_conv.is_owned = (announcement_message_arg & 1) || (announcement_message_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(announcement_message_arg_conv);
announcement_message_arg_conv = NodeAnnouncement_clone(&announcement_message_arg_conv);
LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_new(features_arg_conv, last_update_arg, rgb_arg_ref, alias_arg_ref, addresses_arg_constr, announcement_message_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg) {
+ LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKNodeAnnouncementInfo arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NodeAnnouncementInfo_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKNodeAnnouncementInfo orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeAnnouncementInfo obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NodeAnnouncementInfo_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKNodeInfo this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NodeInfo_free(this_obj_conv);
}
LDKNodeInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u64Z val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
LDKNodeInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees ret_var = NodeInfo_get_lowest_inbound_channel_fees(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = RoutingFees_clone(&val_conv);
NodeInfo_set_lowest_inbound_channel_fees(&this_ptr_conv, val_conv);
}
LDKNodeInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeAnnouncementInfo ret_var = NodeInfo_get_announcement_info(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeAnnouncementInfo val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeAnnouncementInfo_clone(&val_conv);
NodeInfo_set_announcement_info(&this_ptr_conv, val_conv);
}
LDKRoutingFees lowest_inbound_channel_fees_arg_conv;
lowest_inbound_channel_fees_arg_conv.inner = (void*)(lowest_inbound_channel_fees_arg & (~1));
lowest_inbound_channel_fees_arg_conv.is_owned = (lowest_inbound_channel_fees_arg & 1) || (lowest_inbound_channel_fees_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(lowest_inbound_channel_fees_arg_conv);
lowest_inbound_channel_fees_arg_conv = RoutingFees_clone(&lowest_inbound_channel_fees_arg_conv);
LDKNodeAnnouncementInfo announcement_info_arg_conv;
announcement_info_arg_conv.inner = (void*)(announcement_info_arg & (~1));
announcement_info_arg_conv.is_owned = (announcement_info_arg & 1) || (announcement_info_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(announcement_info_arg_conv);
announcement_info_arg_conv = NodeAnnouncementInfo_clone(&announcement_info_arg_conv);
LDKNodeInfo ret_var = NodeInfo_new(channels_arg_constr, lowest_inbound_channel_fees_arg_conv, announcement_info_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg) {
+ LDKNodeInfo ret_var = NodeInfo_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeInfo_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKNodeInfo arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NodeInfo_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeInfo_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKNodeInfo orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNodeInfo ret_var = NodeInfo_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeInfo obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NodeInfo_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKNetworkGraph obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NetworkGraph_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKReadOnlyNetworkGraph ret_var = NetworkGraph_read_only(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKNodeAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = NetworkGraph_update_node_from_announcement(&this_arg_conv, &msg_conv);
return (uint64_t)ret_conv;
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKUnsignedNodeAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = NetworkGraph_update_node_from_unsigned_announcement(&this_arg_conv, &msg_conv);
return (uint64_t)ret_conv;
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
void* chain_access_ptr = (void*)(((uint64_t)chain_access) & ~1);
CHECK_ACCESS(chain_access_ptr);
LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKUnsignedChannelAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
void* chain_access_ptr = (void*)(((uint64_t)chain_access) & ~1);
CHECK_ACCESS(chain_access_ptr);
LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
NetworkGraph_close_channel_from_update(&this_arg_conv, short_channel_id, is_permanent);
}
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPublicKey _node_id_ref;
CHECK((*env)->GetArrayLength(env, _node_id) == 33);
(*env)->GetByteArrayRegion(env, _node_id, 0, 33, _node_id_ref.compressed_form);
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = NetworkGraph_update_channel(&this_arg_conv, &msg_conv);
return (uint64_t)ret_conv;
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKUnsignedChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = NetworkGraph_update_channel_unsigned(&this_arg_conv, &msg_conv);
return (uint64_t)ret_conv;
LDKReadOnlyNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPublicKey pubkey_ref;
CHECK((*env)->GetArrayLength(env, pubkey) == 33);
(*env)->GetByteArrayRegion(env, pubkey, 0, 33, pubkey_ref.compressed_form);
LDKRouteHop this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RouteHop_free(this_obj_conv);
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, RouteHop_get_pubkey(&this_ptr_conv).compressed_form);
return ret_arr;
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures ret_var = RouteHop_get_node_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeFeatures_clone(&val_conv);
RouteHop_set_node_features(&this_ptr_conv, val_conv);
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = RouteHop_get_short_channel_id(&this_ptr_conv);
return ret_val;
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteHop_set_short_channel_id(&this_ptr_conv, val);
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures ret_var = RouteHop_get_channel_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelFeatures_clone(&val_conv);
RouteHop_set_channel_features(&this_ptr_conv, val_conv);
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = RouteHop_get_fee_msat(&this_ptr_conv);
return ret_val;
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteHop_set_fee_msat(&this_ptr_conv, val);
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = RouteHop_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteHop_set_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKNodeFeatures node_features_arg_conv;
node_features_arg_conv.inner = (void*)(node_features_arg & (~1));
node_features_arg_conv.is_owned = (node_features_arg & 1) || (node_features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(node_features_arg_conv);
node_features_arg_conv = NodeFeatures_clone(&node_features_arg_conv);
LDKChannelFeatures channel_features_arg_conv;
channel_features_arg_conv.inner = (void*)(channel_features_arg & (~1));
channel_features_arg_conv.is_owned = (channel_features_arg & 1) || (channel_features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_features_arg_conv);
channel_features_arg_conv = ChannelFeatures_clone(&channel_features_arg_conv);
LDKRouteHop ret_var = RouteHop_new(pubkey_arg_ref, node_features_arg_conv, short_channel_id_arg, channel_features_arg_conv, fee_msat_arg, cltv_expiry_delta_arg);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg) {
+ LDKRouteHop ret_var = RouteHop_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHop_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKRouteHop arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RouteHop_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHop_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKRouteHop orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRouteHop ret_var = RouteHop_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHop o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = RouteHop_hash(&o_conv);
return ret_val;
}
LDKRouteHop a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRouteHop b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RouteHop_eq(&a_conv, &b_conv);
return ret_val;
}
LDKRouteHop obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RouteHop_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKRoute this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Route_free(this_obj_conv);
}
LDKRoute this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_CVec_RouteHopZZ ret_var = Route_get_paths(&this_ptr_conv);
jobjectArray ret_arr = NULL;
ret_arr = (*env)->NewObjectArray(env, ret_var.datalen, arr_of_J_clz, NULL);
uint64_t ret_conv_12_conv_10_ref = 0;
CHECK((((uint64_t)ret_conv_12_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_12_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_12_conv_10_var);
ret_conv_12_conv_10_ref = (uint64_t)ret_conv_12_conv_10_var.inner;
if (ret_conv_12_conv_10_var.is_owned) {
ret_conv_12_conv_10_ref |= 1;
LDKRoute this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_CVec_RouteHopZZ val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
LDKRouteHop val_conv_12_conv_10_conv;
val_conv_12_conv_10_conv.inner = (void*)(val_conv_12_conv_10 & (~1));
val_conv_12_conv_10_conv.is_owned = (val_conv_12_conv_10 & 1) || (val_conv_12_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_12_conv_10_conv);
val_conv_12_conv_10_conv = RouteHop_clone(&val_conv_12_conv_10_conv);
val_conv_12_constr.data[k] = val_conv_12_conv_10_conv;
}
LDKRoute this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPayee ret_var = Route_get_payee(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRoute this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPayee val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = Payee_clone(&val_conv);
Route_set_payee(&this_ptr_conv, val_conv);
}
LDKRouteHop paths_arg_conv_12_conv_10_conv;
paths_arg_conv_12_conv_10_conv.inner = (void*)(paths_arg_conv_12_conv_10 & (~1));
paths_arg_conv_12_conv_10_conv.is_owned = (paths_arg_conv_12_conv_10 & 1) || (paths_arg_conv_12_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(paths_arg_conv_12_conv_10_conv);
paths_arg_conv_12_conv_10_conv = RouteHop_clone(&paths_arg_conv_12_conv_10_conv);
paths_arg_conv_12_constr.data[k] = paths_arg_conv_12_conv_10_conv;
}
LDKPayee payee_arg_conv;
payee_arg_conv.inner = (void*)(payee_arg & (~1));
payee_arg_conv.is_owned = (payee_arg & 1) || (payee_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(payee_arg_conv);
payee_arg_conv = Payee_clone(&payee_arg_conv);
LDKRoute ret_var = Route_new(paths_arg_constr, payee_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg) {
+ LDKRoute ret_var = Route_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Route_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKRoute arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Route_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Route_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKRoute orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRoute ret_var = Route_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRoute o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = Route_hash(&o_conv);
return ret_val;
}
LDKRoute a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRoute b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = Route_eq(&a_conv, &b_conv);
return ret_val;
}
LDKRoute this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = Route_get_total_fees(&this_arg_conv);
return ret_val;
}
LDKRoute this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = Route_get_total_amount(&this_arg_conv);
return ret_val;
}
LDKRoute obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Route_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKRouteParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RouteParameters_free(this_obj_conv);
}
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPayee ret_var = RouteParameters_get_payee(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPayee val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = Payee_clone(&val_conv);
RouteParameters_set_payee(&this_ptr_conv, val_conv);
}
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = RouteParameters_get_final_value_msat(&this_ptr_conv);
return ret_val;
}
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteParameters_set_final_value_msat(&this_ptr_conv, val);
}
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = RouteParameters_get_final_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteParameters_set_final_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKPayee payee_arg_conv;
payee_arg_conv.inner = (void*)(payee_arg & (~1));
payee_arg_conv.is_owned = (payee_arg & 1) || (payee_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(payee_arg_conv);
payee_arg_conv = Payee_clone(&payee_arg_conv);
LDKRouteParameters ret_var = RouteParameters_new(payee_arg_conv, final_value_msat_arg, final_cltv_expiry_delta_arg);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg) {
+ LDKRouteParameters ret_var = RouteParameters_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteParameters_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKRouteParameters arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RouteParameters_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteParameters_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKRouteParameters orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRouteParameters ret_var = RouteParameters_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteParameters obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RouteParameters_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKPayee this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Payee_free(this_obj_conv);
}
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, Payee_get_pubkey(&this_ptr_conv).compressed_form);
return ret_arr;
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInvoiceFeatures ret_var = Payee_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInvoiceFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = InvoiceFeatures_clone(&val_conv);
Payee_set_features(&this_ptr_conv, val_conv);
}
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_RouteHintZ ret_var = Payee_get_route_hints(&this_ptr_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_11_ref = 0;
CHECK((((uint64_t)ret_conv_11_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_11_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_11_var);
ret_conv_11_ref = (uint64_t)ret_conv_11_var.inner;
if (ret_conv_11_var.is_owned) {
ret_conv_11_ref |= 1;
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_RouteHintZ val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
LDKRouteHint val_conv_11_conv;
val_conv_11_conv.inner = (void*)(val_conv_11 & (~1));
val_conv_11_conv.is_owned = (val_conv_11 & 1) || (val_conv_11 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_11_conv);
val_conv_11_conv = RouteHint_clone(&val_conv_11_conv);
val_constr.data[l] = val_conv_11_conv;
}
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = Payee_get_expiry_time(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKInvoiceFeatures features_arg_conv;
features_arg_conv.inner = (void*)(features_arg & (~1));
features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
features_arg_conv = InvoiceFeatures_clone(&features_arg_conv);
LDKCVec_RouteHintZ route_hints_arg_constr;
route_hints_arg_constr.datalen = (*env)->GetArrayLength(env, route_hints_arg);
LDKRouteHint route_hints_arg_conv_11_conv;
route_hints_arg_conv_11_conv.inner = (void*)(route_hints_arg_conv_11 & (~1));
route_hints_arg_conv_11_conv.is_owned = (route_hints_arg_conv_11 & 1) || (route_hints_arg_conv_11 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_hints_arg_conv_11_conv);
route_hints_arg_conv_11_conv = RouteHint_clone(&route_hints_arg_conv_11_conv);
route_hints_arg_constr.data[l] = route_hints_arg_conv_11_conv;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Payee_clone_ptr(LDKPayee *NONNULL_PTR arg) {
+ LDKPayee ret_var = Payee_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Payee_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKPayee arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Payee_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Payee_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKPayee orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPayee ret_var = Payee_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPayee o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = Payee_hash(&o_conv);
return ret_val;
}
LDKPayee a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKPayee b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = Payee_eq(&a_conv, &b_conv);
return ret_val;
}
LDKPayee obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Payee_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHint this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RouteHint_free(this_obj_conv);
}
LDKRouteHint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_RouteHintHopZ ret_var = RouteHint_get_a(&this_ptr_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_14_ref = 0;
CHECK((((uint64_t)ret_conv_14_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_14_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
ret_conv_14_ref = (uint64_t)ret_conv_14_var.inner;
if (ret_conv_14_var.is_owned) {
ret_conv_14_ref |= 1;
LDKRouteHint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_RouteHintHopZ val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
LDKRouteHintHop val_conv_14_conv;
val_conv_14_conv.inner = (void*)(val_conv_14 & (~1));
val_conv_14_conv.is_owned = (val_conv_14 & 1) || (val_conv_14 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_14_conv);
val_conv_14_conv = RouteHintHop_clone(&val_conv_14_conv);
val_constr.data[o] = val_conv_14_conv;
}
LDKRouteHintHop a_arg_conv_14_conv;
a_arg_conv_14_conv.inner = (void*)(a_arg_conv_14 & (~1));
a_arg_conv_14_conv.is_owned = (a_arg_conv_14 & 1) || (a_arg_conv_14 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_arg_conv_14_conv);
a_arg_conv_14_conv = RouteHintHop_clone(&a_arg_conv_14_conv);
a_arg_constr.data[o] = a_arg_conv_14_conv;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg) {
+ LDKRouteHint ret_var = RouteHint_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHint_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKRouteHint arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RouteHint_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHint_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKRouteHint orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRouteHint ret_var = RouteHint_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHint o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = RouteHint_hash(&o_conv);
return ret_val;
}
LDKRouteHint a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRouteHint b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RouteHint_eq(&a_conv, &b_conv);
return ret_val;
}
LDKRouteHint obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RouteHint_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKRouteHintHop this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RouteHintHop_free(this_obj_conv);
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, RouteHintHop_get_src_node_id(&this_ptr_conv).compressed_form);
return ret_arr;
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = RouteHintHop_get_short_channel_id(&this_ptr_conv);
return ret_val;
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteHintHop_set_short_channel_id(&this_ptr_conv, val);
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees ret_var = RouteHintHop_get_fees(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = RoutingFees_clone(&val_conv);
RouteHintHop_set_fees(&this_ptr_conv, val_conv);
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = RouteHintHop_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteHintHop_set_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = RouteHintHop_get_htlc_minimum_msat(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = RouteHintHop_get_htlc_maximum_msat(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKRoutingFees fees_arg_conv;
fees_arg_conv.inner = (void*)(fees_arg & (~1));
fees_arg_conv.is_owned = (fees_arg & 1) || (fees_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(fees_arg_conv);
fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
void* htlc_minimum_msat_arg_ptr = (void*)(((uint64_t)htlc_minimum_msat_arg) & ~1);
CHECK_ACCESS(htlc_minimum_msat_arg_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg) {
+ LDKRouteHintHop ret_var = RouteHintHop_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHintHop_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKRouteHintHop arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RouteHintHop_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHintHop_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKRouteHintHop orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRouteHintHop ret_var = RouteHintHop_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHintHop o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = RouteHintHop_hash(&o_conv);
return ret_val;
}
LDKRouteHintHop a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRouteHintHop b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RouteHintHop_eq(&a_conv, &b_conv);
return ret_val;
}
LDKRouteHintHop obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RouteHintHop_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKRouteParameters params_conv;
params_conv.inner = (void*)(params & (~1));
params_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
LDKNetworkGraph network_conv;
network_conv.inner = (void*)(network & (~1));
network_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(network_conv);
LDKCVec_ChannelDetailsZ first_hops_constr;
LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL;
if (first_hops != NULL) {
LDKChannelDetails first_hops_conv_16_conv;
first_hops_conv_16_conv.inner = (void*)(first_hops_conv_16 & (~1));
first_hops_conv_16_conv.is_owned = (first_hops_conv_16 & 1) || (first_hops_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_conv);
first_hops_constr.data[q] = first_hops_conv_16_conv;
}
(*env)->ReleaseLongArrayElements(env, first_hops, first_hops_vals, 0);
LDKScorer this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Scorer_free(this_obj_conv);
}
LDKScoringParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ScoringParameters_free(this_obj_conv);
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ScoringParameters_get_base_penalty_msat(&this_ptr_conv);
return ret_val;
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ScoringParameters_set_base_penalty_msat(&this_ptr_conv, val);
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ScoringParameters_get_failure_penalty_msat(&this_ptr_conv);
return ret_val;
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ScoringParameters_set_failure_penalty_msat(&this_ptr_conv, val);
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ScoringParameters_get_failure_penalty_half_life(&this_ptr_conv);
return ret_val;
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ScoringParameters_set_failure_penalty_half_life(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKScoringParameters obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ScoringParameters_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKScoringParameters params_conv;
params_conv.inner = (void*)(params & (~1));
params_conv.is_owned = (params & 1) || (params == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
// Warning: we need a move here but no clone is available for LDKScoringParameters
LDKScorer ret_var = Scorer_new(params_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKScorer this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
*ret_ret = Scorer_as_Score(&this_arg_conv);
return (uint64_t)ret_ret;
LDKScorer obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Scorer_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKFilesystemPersister this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
FilesystemPersister_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKFilesystemPersister this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKStr ret_str = FilesystemPersister_get_data_dir(&this_arg_conv);
jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
Str_free(ret_str);
LDKChannelManager manager_conv;
manager_conv.inner = (void*)(manager & (~1));
manager_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(manager_conv);
LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
*ret_conv = FilesystemPersister_persist_manager(data_dir_conv, &manager_conv);
return (uint64_t)ret_conv;
LDKFilesystemPersister this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* keys_manager_ptr = (void*)(((uint64_t)keys_manager) & ~1);
CHECK_ACCESS(keys_manager_ptr);
LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(keys_manager_ptr);
LDKFilesystemPersister this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPersist* ret_ret = MALLOC(sizeof(LDKPersist), "LDKPersist");
*ret_ret = FilesystemPersister_as_Persist(&this_arg_conv);
return (uint64_t)ret_ret;
LDKBackgroundProcessor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
BackgroundProcessor_free(this_obj_conv);
}
LDKChainMonitor chain_monitor_conv;
chain_monitor_conv.inner = (void*)(chain_monitor & (~1));
chain_monitor_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(chain_monitor_conv);
LDKChannelManager channel_manager_conv;
channel_manager_conv.inner = (void*)(channel_manager & (~1));
channel_manager_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_manager_conv);
LDKNetGraphMsgHandler net_graph_msg_handler_conv;
net_graph_msg_handler_conv.inner = (void*)(net_graph_msg_handler & (~1));
net_graph_msg_handler_conv.is_owned = (net_graph_msg_handler & 1) || (net_graph_msg_handler == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(net_graph_msg_handler_conv);
LDKPeerManager peer_manager_conv;
peer_manager_conv.inner = (void*)(peer_manager & (~1));
peer_manager_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(peer_manager_conv);
void* logger_ptr = (void*)(((uint64_t)logger) & ~1);
CHECK_ACCESS(logger_ptr);
LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKBackgroundProcessor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
// Warning: we need a move here but no clone is available for LDKBackgroundProcessor
LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
*ret_conv = BackgroundProcessor_join(this_arg_conv);
LDKBackgroundProcessor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
// Warning: we need a move here but no clone is available for LDKBackgroundProcessor
LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
*ret_conv = BackgroundProcessor_stop(this_arg_conv);
LDKInvoice this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Invoice_free(this_obj_conv);
}
LDKInvoice a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKInvoice b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = Invoice_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg) {
+ LDKInvoice ret_var = Invoice_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Invoice_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKInvoice arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Invoice_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Invoice_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKInvoice orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInvoice ret_var = Invoice_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKSignedRawInvoice this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
SignedRawInvoice_free(this_obj_conv);
}
LDKSignedRawInvoice a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKSignedRawInvoice b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = SignedRawInvoice_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg) {
+ LDKSignedRawInvoice ret_var = SignedRawInvoice_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SignedRawInvoice_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKSignedRawInvoice arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = SignedRawInvoice_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SignedRawInvoice_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKSignedRawInvoice orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKSignedRawInvoice ret_var = SignedRawInvoice_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RawInvoice_free(this_obj_conv);
}
LDKRawInvoice this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRawDataPart ret_var = RawInvoice_get_data(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRawDataPart val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = RawDataPart_clone(&val_conv);
RawInvoice_set_data(&this_ptr_conv, val_conv);
}
LDKRawInvoice a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRawInvoice b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RawInvoice_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg) {
+ LDKRawInvoice ret_var = RawInvoice_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RawInvoice_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKRawInvoice arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RawInvoice_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RawInvoice_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKRawInvoice orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRawInvoice ret_var = RawInvoice_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawDataPart this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RawDataPart_free(this_obj_conv);
}
LDKRawDataPart this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPositiveTimestamp ret_var = RawDataPart_get_timestamp(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawDataPart this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPositiveTimestamp val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = PositiveTimestamp_clone(&val_conv);
RawDataPart_set_timestamp(&this_ptr_conv, val_conv);
}
LDKRawDataPart a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRawDataPart b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RawDataPart_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg) {
+ LDKRawDataPart ret_var = RawDataPart_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RawDataPart_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKRawDataPart arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RawDataPart_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RawDataPart_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKRawDataPart orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRawDataPart ret_var = RawDataPart_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPositiveTimestamp this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
PositiveTimestamp_free(this_obj_conv);
}
LDKPositiveTimestamp a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKPositiveTimestamp b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = PositiveTimestamp_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg) {
+ LDKPositiveTimestamp ret_var = PositiveTimestamp_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PositiveTimestamp_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKPositiveTimestamp arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = PositiveTimestamp_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PositiveTimestamp_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKPositiveTimestamp orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPositiveTimestamp ret_var = PositiveTimestamp_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKSha256 this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Sha256_free(this_obj_conv);
}
+static inline uint64_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg) {
+ LDKSha256 ret_var = Sha256_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Sha256_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKSha256 arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Sha256_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Sha256_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKSha256 orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKSha256 ret_var = Sha256_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKSha256 o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = Sha256_hash(&o_conv);
return ret_val;
}
LDKSha256 a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKSha256 b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = Sha256_eq(&a_conv, &b_conv);
return ret_val;
}
LDKDescription this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Description_free(this_obj_conv);
}
+static inline uint64_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg) {
+ LDKDescription ret_var = Description_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Description_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKDescription arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Description_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Description_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKDescription orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKDescription ret_var = Description_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDescription o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = Description_hash(&o_conv);
return ret_val;
}
LDKDescription a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKDescription b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = Description_eq(&a_conv, &b_conv);
return ret_val;
}
LDKPayeePubKey this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
PayeePubKey_free(this_obj_conv);
}
LDKPayeePubKey this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, PayeePubKey_get_a(&this_ptr_conv).compressed_form);
return ret_arr;
LDKPayeePubKey this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg) {
+ LDKPayeePubKey ret_var = PayeePubKey_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PayeePubKey_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKPayeePubKey arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = PayeePubKey_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PayeePubKey_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKPayeePubKey orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPayeePubKey ret_var = PayeePubKey_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPayeePubKey o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = PayeePubKey_hash(&o_conv);
return ret_val;
}
LDKPayeePubKey a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKPayeePubKey b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = PayeePubKey_eq(&a_conv, &b_conv);
return ret_val;
}
LDKExpiryTime this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ExpiryTime_free(this_obj_conv);
}
+static inline uint64_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg) {
+ LDKExpiryTime ret_var = ExpiryTime_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ExpiryTime_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKExpiryTime arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ExpiryTime_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ExpiryTime_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKExpiryTime orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKExpiryTime ret_var = ExpiryTime_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKExpiryTime o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = ExpiryTime_hash(&o_conv);
return ret_val;
}
LDKExpiryTime a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKExpiryTime b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = ExpiryTime_eq(&a_conv, &b_conv);
return ret_val;
}
LDKMinFinalCltvExpiry this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
MinFinalCltvExpiry_free(this_obj_conv);
}
LDKMinFinalCltvExpiry this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = MinFinalCltvExpiry_get_a(&this_ptr_conv);
return ret_val;
}
LDKMinFinalCltvExpiry this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
MinFinalCltvExpiry_set_a(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t MinFinalCltvExpiry_clone_ptr(LDKMinFinalCltvExpiry *NONNULL_PTR arg) {
+ LDKMinFinalCltvExpiry ret_var = MinFinalCltvExpiry_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MinFinalCltvExpiry_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKMinFinalCltvExpiry arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = MinFinalCltvExpiry_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MinFinalCltvExpiry_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKMinFinalCltvExpiry orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKMinFinalCltvExpiry ret_var = MinFinalCltvExpiry_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKMinFinalCltvExpiry o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = MinFinalCltvExpiry_hash(&o_conv);
return ret_val;
}
LDKMinFinalCltvExpiry a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKMinFinalCltvExpiry b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = MinFinalCltvExpiry_eq(&a_conv, &b_conv);
return ret_val;
}
Fallback_free(this_ptr_conv);
}
+static inline uint64_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg) {
+ LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
+ *ret_copy = Fallback_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Fallback_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKFallback* arg_conv = (LDKFallback*)arg;
+ int64_t ret_val = Fallback_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Fallback_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKFallback* orig_conv = (LDKFallback*)orig;
LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
LDKInvoiceSignature this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InvoiceSignature_free(this_obj_conv);
}
+static inline uint64_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg) {
+ LDKInvoiceSignature ret_var = InvoiceSignature_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InvoiceSignature_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKInvoiceSignature arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = InvoiceSignature_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InvoiceSignature_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKInvoiceSignature orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInvoiceSignature ret_var = InvoiceSignature_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvoiceSignature a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKInvoiceSignature b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = InvoiceSignature_eq(&a_conv, &b_conv);
return ret_val;
}
LDKPrivateRoute this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
PrivateRoute_free(this_obj_conv);
}
+static inline uint64_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg) {
+ LDKPrivateRoute ret_var = PrivateRoute_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PrivateRoute_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKPrivateRoute arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = PrivateRoute_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PrivateRoute_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKPrivateRoute orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPrivateRoute ret_var = PrivateRoute_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPrivateRoute o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = PrivateRoute_hash(&o_conv);
return ret_val;
}
LDKPrivateRoute a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKPrivateRoute b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = PrivateRoute_eq(&a_conv, &b_conv);
return ret_val;
}
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
this_arg_conv = SignedRawInvoice_clone(&this_arg_conv);
LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
*ret_conv = SignedRawInvoice_into_parts(this_arg_conv);
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRawInvoice ret_var = SignedRawInvoice_raw_invoice(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *SignedRawInvoice_hash(&this_arg_conv));
return ret_arr;
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInvoiceSignature ret_var = SignedRawInvoice_signature(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
*ret_conv = SignedRawInvoice_recover_payee_pub_key(&this_arg_conv);
return (uint64_t)ret_conv;
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = SignedRawInvoice_check_signature(&this_arg_conv);
return ret_val;
}
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, RawInvoice_hash(&this_arg_conv).data);
return ret_arr;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKSha256 ret_var = RawInvoice_payment_hash(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKDescription ret_var = RawInvoice_description(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPayeePubKey ret_var = RawInvoice_payee_pub_key(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKSha256 ret_var = RawInvoice_description_hash(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKExpiryTime ret_var = RawInvoice_expiry_time(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKMinFinalCltvExpiry ret_var = RawInvoice_min_final_cltv_expiry(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, RawInvoice_payment_secret(&this_arg_conv).data);
return ret_arr;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInvoiceFeatures ret_var = RawInvoice_features(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_PrivateRouteZ ret_var = RawInvoice_private_routes(&this_arg_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_14_ref = 0;
CHECK((((uint64_t)ret_conv_14_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_14_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
ret_conv_14_ref = (uint64_t)ret_conv_14_var.inner;
if (ret_conv_14_var.is_owned) {
ret_conv_14_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = RawInvoice_amount_pico_btc(&this_arg_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jclass ret_conv = LDKCurrency_to_java(env, RawInvoice_currency(&this_arg_conv));
return ret_conv;
}
LDKPositiveTimestamp this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = PositiveTimestamp_as_unix_timestamp(&this_arg_conv);
return ret_val;
}
LDKPositiveTimestamp this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = PositiveTimestamp_as_time(&this_arg_conv);
return ret_val;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
this_arg_conv = Invoice_clone(&this_arg_conv);
LDKSignedRawInvoice ret_var = Invoice_into_signed_raw(this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
*ret_conv = Invoice_check_signature(&this_arg_conv);
return (uint64_t)ret_conv;
LDKSignedRawInvoice signed_invoice_conv;
signed_invoice_conv.inner = (void*)(signed_invoice & (~1));
signed_invoice_conv.is_owned = (signed_invoice & 1) || (signed_invoice == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(signed_invoice_conv);
signed_invoice_conv = SignedRawInvoice_clone(&signed_invoice_conv);
LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
*ret_conv = Invoice_from_signed(signed_invoice_conv);
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = Invoice_timestamp(&this_arg_conv);
return ret_val;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *Invoice_payment_hash(&this_arg_conv));
return ret_arr;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, Invoice_payee_pub_key(&this_arg_conv).compressed_form);
return ret_arr;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *Invoice_payment_secret(&this_arg_conv));
return ret_arr;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInvoiceFeatures ret_var = Invoice_features(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, Invoice_recover_payee_pub_key(&this_arg_conv).compressed_form);
return ret_arr;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = Invoice_expiry_time(&this_arg_conv);
return ret_val;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = Invoice_is_expired(&this_arg_conv);
return ret_val;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = Invoice_min_final_cltv_expiry(&this_arg_conv);
return ret_val;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_PrivateRouteZ ret_var = Invoice_private_routes(&this_arg_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_14_ref = 0;
CHECK((((uint64_t)ret_conv_14_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_14_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
ret_conv_14_ref = (uint64_t)ret_conv_14_var.inner;
if (ret_conv_14_var.is_owned) {
ret_conv_14_ref |= 1;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_RouteHintZ ret_var = Invoice_route_hints(&this_arg_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_11_ref = 0;
CHECK((((uint64_t)ret_conv_11_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_11_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_11_var);
ret_conv_11_ref = (uint64_t)ret_conv_11_var.inner;
if (ret_conv_11_var.is_owned) {
ret_conv_11_ref |= 1;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jclass ret_conv = LDKCurrency_to_java(env, Invoice_currency(&this_arg_conv));
return ret_conv;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = Invoice_amount_milli_satoshis(&this_arg_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKDescription this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
this_arg_conv = Description_clone(&this_arg_conv);
LDKStr ret_str = Description_into_inner(this_arg_conv);
jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
LDKExpiryTime this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = ExpiryTime_as_seconds(&this_arg_conv);
return ret_val;
}
LDKExpiryTime this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = ExpiryTime_as_duration(&this_arg_conv);
return ret_val;
}
LDKRouteHint hops_conv;
hops_conv.inner = (void*)(hops & (~1));
hops_conv.is_owned = (hops & 1) || (hops == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(hops_conv);
hops_conv = RouteHint_clone(&hops_conv);
LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
*ret_conv = PrivateRoute_new(hops_conv);
LDKPrivateRoute this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
this_arg_conv = PrivateRoute_clone(&this_arg_conv);
LDKRouteHint ret_var = PrivateRoute_into_inner(this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
SignOrCreationError_free(this_ptr_conv);
}
+static inline uint64_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg) {
+ LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
+ *ret_copy = SignOrCreationError_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SignOrCreationError_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKSignOrCreationError* arg_conv = (LDKSignOrCreationError*)arg;
+ int64_t ret_val = SignOrCreationError_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SignOrCreationError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKSignOrCreationError* orig_conv = (LDKSignOrCreationError*)orig;
LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
LDKInvoicePayer this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InvoicePayer_free(this_obj_conv);
}
LDKRetryAttempts this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RetryAttempts_free(this_obj_conv);
}
LDKRetryAttempts this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = RetryAttempts_get_a(&this_ptr_conv);
return ret_val;
}
LDKRetryAttempts this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RetryAttempts_set_a(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RetryAttempts_clone_ptr(LDKRetryAttempts *NONNULL_PTR arg) {
+ LDKRetryAttempts ret_var = RetryAttempts_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RetryAttempts_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKRetryAttempts arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RetryAttempts_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RetryAttempts_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKRetryAttempts orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRetryAttempts ret_var = RetryAttempts_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRetryAttempts a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRetryAttempts b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RetryAttempts_eq(&a_conv, &b_conv);
return ret_val;
}
LDKRetryAttempts o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = RetryAttempts_hash(&o_conv);
return ret_val;
}
PaymentError_free(this_ptr_conv);
}
+static inline uint64_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg) {
+ LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
+ *ret_copy = PaymentError_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PaymentError_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKPaymentError* arg_conv = (LDKPaymentError*)arg;
+ int64_t ret_val = PaymentError_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PaymentError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKPaymentError* orig_conv = (LDKPaymentError*)orig;
LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
LDKLightningError a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = LightningError_clone(&a_conv);
LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
*ret_copy = PaymentError_routing(a_conv);
LDKLockableScore scorer_conv;
scorer_conv.inner = (void*)(scorer & (~1));
scorer_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(scorer_conv);
void* logger_ptr = (void*)(((uint64_t)logger) & ~1);
CHECK_ACCESS(logger_ptr);
LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
LDKRetryAttempts retry_attempts_conv;
retry_attempts_conv.inner = (void*)(retry_attempts & (~1));
retry_attempts_conv.is_owned = (retry_attempts & 1) || (retry_attempts == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(retry_attempts_conv);
retry_attempts_conv = RetryAttempts_clone(&retry_attempts_conv);
LDKInvoicePayer ret_var = InvoicePayer_new(payer_conv, router_conv, &scorer_conv, logger_conv, event_handler_conv, retry_attempts_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvoicePayer this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInvoice invoice_conv;
invoice_conv.inner = (void*)(invoice & (~1));
invoice_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
*ret_conv = InvoicePayer_pay_invoice(&this_arg_conv, &invoice_conv);
return (uint64_t)ret_conv;
LDKInvoicePayer this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInvoice invoice_conv;
invoice_conv.inner = (void*)(invoice & (~1));
invoice_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
*ret_conv = InvoicePayer_pay_zero_value_invoice(&this_arg_conv, &invoice_conv, amount_msats);
return (uint64_t)ret_conv;
LDKInvoicePayer this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char payment_hash_arr[32];
CHECK((*env)->GetArrayLength(env, payment_hash) == 32);
(*env)->GetByteArrayRegion(env, payment_hash, 0, 32, payment_hash_arr);
LDKInvoicePayer this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKEventHandler* ret_ret = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
*ret_ret = InvoicePayer_as_EventHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager channelmanager_conv;
channelmanager_conv.inner = (void*)(channelmanager & (~1));
channelmanager_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
void* keys_manager_ptr = (void*)(((uint64_t)keys_manager) & ~1);
CHECK_ACCESS(keys_manager_ptr);
LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(keys_manager_ptr);
LDKDefaultRouter this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DefaultRouter_free(this_obj_conv);
}
LDKNetworkGraph network_graph_conv;
network_graph_conv.inner = (void*)(network_graph & (~1));
network_graph_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
void* logger_ptr = (void*)(((uint64_t)logger) & ~1);
CHECK_ACCESS(logger_ptr);
LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDefaultRouter this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRouter* ret_ret = MALLOC(sizeof(LDKRouter), "LDKRouter");
*ret_ret = DefaultRouter_as_Router(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPayer* ret_ret = MALLOC(sizeof(LDKPayer), "LDKPayer");
*ret_ret = ChannelManager_as_Payer(&this_arg_conv);
return (uint64_t)ret_ret;
LDKInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
LDKStr ret_str = Invoice_to_str(&o_conv);
jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
Str_free(ret_str);
LDKSignedRawInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
LDKStr ret_str = SignedRawInvoice_to_str(&o_conv);
jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
Str_free(ret_str);
#define MALLOC(a, _) malloc(a)
#define FREE(p) if ((uint64_t)(p) > 4096) { free(p); }
#define CHECK_ACCESS(p)
+#define CHECK_INNER_FIELD_ACCESS_OR_NULL(v)
#define DO_ASSERT(a) (void)(a)
#define CHECK(a)
}
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1u8Z_1new(JNIEnv *env, jclass clz, int8_tArray elems) {
- LDKCVec_u8Z *ret = MALLOC(sizeof(LDKCVec_u8Z), "LDKCVec_u8Z");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(uint8_t) * ret->datalen, "LDKCVec_u8Z Data");
- int8_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- ret->data[i] = java_elems[i];
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_u8Z CVec_u8Z_clone(const LDKCVec_u8Z *orig) {
LDKCVec_u8Z ret = { .data = MALLOC(sizeof(int8_t) * orig->datalen, "LDKCVec_u8Z clone bytes"), .datalen = orig->datalen };
memcpy(ret.data, orig->data, sizeof(int8_t) * ret.datalen);
return ret_val;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SecretKeyErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_SecretKeyErrorZ*)arg)->result_ok;
-}
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SecretKeyErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_SecretKeyErrorZ *val = (LDKCResult_SecretKeyErrorZ*)(arg & ~1);
CHECK(val->result_ok);
jclass err_conv = LDKSecp256k1Error_to_java(env, (*val->contents.err));
return err_conv;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PublicKeyErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_PublicKeyErrorZ*)arg)->result_ok;
-}
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PublicKeyErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_PublicKeyErrorZ *val = (LDKCResult_PublicKeyErrorZ*)(arg & ~1);
CHECK(val->result_ok);
jclass err_conv = LDKSecp256k1Error_to_java(env, (*val->contents.err));
return err_conv;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_TxCreationKeysDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_TxCreationKeysDecodeErrorZ *val = (LDKCResult_TxCreationKeysDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelPublicKeysDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ChannelPublicKeysDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelPublicKeysDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ChannelPublicKeysDecodeErrorZ *val = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_TxCreationKeysErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_TxCreationKeysErrorZ *val = (LDKCResult_TxCreationKeysErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
default: abort();
}
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCOutputInCommitmentDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCOutputInCommitmentDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *val = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *val = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelTransactionParametersDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ChannelTransactionParametersDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelTransactionParametersDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ChannelTransactionParametersDecodeErrorZ *val = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HolderCommitmentTransactionDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HolderCommitmentTransactionDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_HolderCommitmentTransactionDecodeErrorZ *val = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1BuiltCommitmentTransactionDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1BuiltCommitmentTransactionDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *val = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TrustedClosingTransactionNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_TrustedClosingTransactionNoneZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TrustedClosingTransactionNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_TrustedClosingTransactionNoneZ *val = (LDKCResult_TrustedClosingTransactionNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
CHECK(!val->result_ok);
return *val->contents.err;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentTransactionDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_CommitmentTransactionDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentTransactionDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_CommitmentTransactionDecodeErrorZ *val = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TrustedCommitmentTransactionNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_TrustedCommitmentTransactionNoneZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TrustedCommitmentTransactionNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_TrustedCommitmentTransactionNoneZ *val = (LDKCResult_TrustedCommitmentTransactionNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
CHECK(!val->result_ok);
return *val->contents.err;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1SignatureZNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_CVec_SignatureZNoneZ*)arg)->result_ok;
-}
JNIEXPORT jobjectArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1SignatureZNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_CVec_SignatureZNoneZ *val = (LDKCResult_CVec_SignatureZNoneZ*)(arg & ~1);
CHECK(val->result_ok);
CHECK(!val->result_ok);
return *val->contents.err;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownScriptDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ShutdownScriptDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownScriptDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ShutdownScriptDecodeErrorZ *val = (LDKCResult_ShutdownScriptDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownScriptInvalidShutdownScriptZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownScriptInvalidShutdownScriptZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ShutdownScriptInvalidShutdownScriptZ *val = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NoneErrorZ*)arg)->result_ok;
-}
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NoneErrorZ *val = (LDKCResult_NoneErrorZ*)(arg & ~1);
CHECK(val->result_ok);
jclass err_conv = LDKIOError_to_java(env, (*val->contents.err));
return err_conv;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteHopDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_RouteHopDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteHopDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_RouteHopDecodeErrorZ *val = (LDKCResult_RouteHopDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1RouteHopZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_RouteHopZ *ret = MALLOC(sizeof(LDKCVec_RouteHopZ), "LDKCVec_RouteHopZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKRouteHop) * ret->datalen, "LDKCVec_RouteHopZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKRouteHop arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = RouteHop_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_RouteHopZ CVec_RouteHopZ_clone(const LDKCVec_RouteHopZ *orig) {
LDKCVec_RouteHopZ ret = { .data = MALLOC(sizeof(LDKRouteHop) * orig->datalen, "LDKCVec_RouteHopZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_RouteDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_RouteDecodeErrorZ *val = (LDKCResult_RouteDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteParametersDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_RouteParametersDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteParametersDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_RouteParametersDecodeErrorZ *val = (LDKCResult_RouteParametersDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1RouteHintZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_RouteHintZ *ret = MALLOC(sizeof(LDKCVec_RouteHintZ), "LDKCVec_RouteHintZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKRouteHint) * ret->datalen, "LDKCVec_RouteHintZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKRouteHint arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = RouteHint_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_RouteHintZ CVec_RouteHintZ_clone(const LDKCVec_RouteHintZ *orig) {
LDKCVec_RouteHintZ ret = { .data = MALLOC(sizeof(LDKRouteHint) * orig->datalen, "LDKCVec_RouteHintZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
default: abort();
}
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PayeeDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_PayeeDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PayeeDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_PayeeDecodeErrorZ *val = (LDKCResult_PayeeDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1RouteHintHopZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_RouteHintHopZ *ret = MALLOC(sizeof(LDKCVec_RouteHintHopZ), "LDKCVec_RouteHintHopZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKRouteHintHop) * ret->datalen, "LDKCVec_RouteHintHopZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKRouteHintHop arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = RouteHintHop_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_RouteHintHopZ CVec_RouteHintHopZ_clone(const LDKCVec_RouteHintHopZ *orig) {
LDKCVec_RouteHintHopZ ret = { .data = MALLOC(sizeof(LDKRouteHintHop) * orig->datalen, "LDKCVec_RouteHintHopZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteHintDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_RouteHintDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteHintDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_RouteHintDecodeErrorZ *val = (LDKCResult_RouteHintDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteHintHopDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_RouteHintHopDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteHintHopDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_RouteHintHopDecodeErrorZ *val = (LDKCResult_RouteHintHopDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1ChannelDetailsZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_ChannelDetailsZ *ret = MALLOC(sizeof(LDKCVec_ChannelDetailsZ), "LDKCVec_ChannelDetailsZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKChannelDetails) * ret->datalen, "LDKCVec_ChannelDetailsZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKChannelDetails arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = ChannelDetails_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_ChannelDetailsZ CVec_ChannelDetailsZ_clone(const LDKCVec_ChannelDetailsZ *orig) {
LDKCVec_ChannelDetailsZ ret = { .data = MALLOC(sizeof(LDKChannelDetails) * orig->datalen, "LDKCVec_ChannelDetailsZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteLightningErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_RouteLightningErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteLightningErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_RouteLightningErrorZ *val = (LDKCResult_RouteLightningErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxOutAccessErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_TxOutAccessErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxOutAccessErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_TxOutAccessErrorZ *val = (LDKCResult_TxOutAccessErrorZ*)(arg & ~1);
CHECK(val->result_ok);
return ret_arr;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1usizeTransactionZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_C2Tuple_usizeTransactionZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_usizeTransactionZZ), "LDKCVec_C2Tuple_usizeTransactionZZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ) * ret->datalen, "LDKCVec_C2Tuple_usizeTransactionZZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_usizeTransactionZ arr_elem_conv = *(LDKC2Tuple_usizeTransactionZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_usizeTransactionZZ CVec_C2Tuple_usizeTransactionZZ_clone(const LDKCVec_C2Tuple_usizeTransactionZZ *orig) {
LDKCVec_C2Tuple_usizeTransactionZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ) * orig->datalen, "LDKCVec_C2Tuple_usizeTransactionZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneChannelMonitorUpdateErrZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NoneChannelMonitorUpdateErrZ*)arg)->result_ok;
-}
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneChannelMonitorUpdateErrZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NoneChannelMonitorUpdateErrZ *val = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t htlc_event_ref = 0;
CHECK((((uint64_t)htlc_event_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&htlc_event_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_event_var);
htlc_event_ref = (uint64_t)htlc_event_var.inner & ~1;
return (*env)->NewObject(env, LDKMonitorEvent_HTLCEvent_class, LDKMonitorEvent_HTLCEvent_meth, htlc_event_ref);
}
uint64_t commitment_tx_confirmed_ref = 0;
CHECK((((uint64_t)commitment_tx_confirmed_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&commitment_tx_confirmed_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_confirmed_var);
commitment_tx_confirmed_ref = (uint64_t)commitment_tx_confirmed_var.inner & ~1;
return (*env)->NewObject(env, LDKMonitorEvent_CommitmentTxConfirmed_class, LDKMonitorEvent_CommitmentTxConfirmed_meth, commitment_tx_confirmed_ref);
}
uint64_t funding_txo_ref = 0;
CHECK((((uint64_t)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
funding_txo_ref = (uint64_t)funding_txo_var.inner & ~1;
return (*env)->NewObject(env, LDKMonitorEvent_UpdateCompleted_class, LDKMonitorEvent_UpdateCompleted_meth, funding_txo_ref, obj->update_completed.monitor_update_id);
}
uint64_t update_failed_ref = 0;
CHECK((((uint64_t)update_failed_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_failed_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_failed_var);
update_failed_ref = (uint64_t)update_failed_var.inner & ~1;
return (*env)->NewObject(env, LDKMonitorEvent_UpdateFailed_class, LDKMonitorEvent_UpdateFailed_meth, update_failed_ref);
}
default: abort();
}
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1MonitorEventZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_MonitorEventZ *ret = MALLOC(sizeof(LDKCVec_MonitorEventZ), "LDKCVec_MonitorEventZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKMonitorEvent) * ret->datalen, "LDKCVec_MonitorEventZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKMonitorEvent arr_elem_conv = *(LDKMonitorEvent*)(arr_elem_ptr);
- arr_elem_conv = MonitorEvent_clone((LDKMonitorEvent*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_MonitorEventZ CVec_MonitorEventZ_clone(const LDKCVec_MonitorEventZ *orig) {
LDKCVec_MonitorEventZ ret = { .data = MALLOC(sizeof(LDKMonitorEvent) * orig->datalen, "LDKCVec_MonitorEventZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
default: abort();
}
}
+static jclass LDKClosureReason_CounterpartyForceClosed_class = NULL;
+static jmethodID LDKClosureReason_CounterpartyForceClosed_meth = NULL;
+static jclass LDKClosureReason_HolderForceClosed_class = NULL;
+static jmethodID LDKClosureReason_HolderForceClosed_meth = NULL;
+static jclass LDKClosureReason_CooperativeClosure_class = NULL;
+static jmethodID LDKClosureReason_CooperativeClosure_meth = NULL;
+static jclass LDKClosureReason_CommitmentTxConfirmed_class = NULL;
+static jmethodID LDKClosureReason_CommitmentTxConfirmed_meth = NULL;
+static jclass LDKClosureReason_ProcessingError_class = NULL;
+static jmethodID LDKClosureReason_ProcessingError_meth = NULL;
+static jclass LDKClosureReason_DisconnectedPeer_class = NULL;
+static jmethodID LDKClosureReason_DisconnectedPeer_meth = NULL;
+static jclass LDKClosureReason_OutdatedChannelManager_class = NULL;
+static jmethodID LDKClosureReason_OutdatedChannelManager_meth = NULL;
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKClosureReason_init (JNIEnv *env, jclass clz) {
+ LDKClosureReason_CounterpartyForceClosed_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$CounterpartyForceClosed;"));
+ CHECK(LDKClosureReason_CounterpartyForceClosed_class != NULL);
+ LDKClosureReason_CounterpartyForceClosed_meth = (*env)->GetMethodID(env, LDKClosureReason_CounterpartyForceClosed_class, "<init>", "(Ljava/lang/String;)V");
+ CHECK(LDKClosureReason_CounterpartyForceClosed_meth != NULL);
+ LDKClosureReason_HolderForceClosed_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$HolderForceClosed;"));
+ CHECK(LDKClosureReason_HolderForceClosed_class != NULL);
+ LDKClosureReason_HolderForceClosed_meth = (*env)->GetMethodID(env, LDKClosureReason_HolderForceClosed_class, "<init>", "()V");
+ CHECK(LDKClosureReason_HolderForceClosed_meth != NULL);
+ LDKClosureReason_CooperativeClosure_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$CooperativeClosure;"));
+ CHECK(LDKClosureReason_CooperativeClosure_class != NULL);
+ LDKClosureReason_CooperativeClosure_meth = (*env)->GetMethodID(env, LDKClosureReason_CooperativeClosure_class, "<init>", "()V");
+ CHECK(LDKClosureReason_CooperativeClosure_meth != NULL);
+ LDKClosureReason_CommitmentTxConfirmed_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$CommitmentTxConfirmed;"));
+ CHECK(LDKClosureReason_CommitmentTxConfirmed_class != NULL);
+ LDKClosureReason_CommitmentTxConfirmed_meth = (*env)->GetMethodID(env, LDKClosureReason_CommitmentTxConfirmed_class, "<init>", "()V");
+ CHECK(LDKClosureReason_CommitmentTxConfirmed_meth != NULL);
+ LDKClosureReason_ProcessingError_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$ProcessingError;"));
+ CHECK(LDKClosureReason_ProcessingError_class != NULL);
+ LDKClosureReason_ProcessingError_meth = (*env)->GetMethodID(env, LDKClosureReason_ProcessingError_class, "<init>", "(Ljava/lang/String;)V");
+ CHECK(LDKClosureReason_ProcessingError_meth != NULL);
+ LDKClosureReason_DisconnectedPeer_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$DisconnectedPeer;"));
+ CHECK(LDKClosureReason_DisconnectedPeer_class != NULL);
+ LDKClosureReason_DisconnectedPeer_meth = (*env)->GetMethodID(env, LDKClosureReason_DisconnectedPeer_class, "<init>", "()V");
+ CHECK(LDKClosureReason_DisconnectedPeer_meth != NULL);
+ LDKClosureReason_OutdatedChannelManager_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$OutdatedChannelManager;"));
+ CHECK(LDKClosureReason_OutdatedChannelManager_class != NULL);
+ LDKClosureReason_OutdatedChannelManager_meth = (*env)->GetMethodID(env, LDKClosureReason_OutdatedChannelManager_class, "<init>", "()V");
+ CHECK(LDKClosureReason_OutdatedChannelManager_meth != NULL);
+}
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKClosureReason_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
+ LDKClosureReason *obj = (LDKClosureReason*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKClosureReason_CounterpartyForceClosed: {
+ LDKStr peer_msg_str = obj->counterparty_force_closed.peer_msg;
+ jstring peer_msg_conv = str_ref_to_java(env, peer_msg_str.chars, peer_msg_str.len);
+ return (*env)->NewObject(env, LDKClosureReason_CounterpartyForceClosed_class, LDKClosureReason_CounterpartyForceClosed_meth, peer_msg_conv);
+ }
+ case LDKClosureReason_HolderForceClosed: {
+ return (*env)->NewObject(env, LDKClosureReason_HolderForceClosed_class, LDKClosureReason_HolderForceClosed_meth);
+ }
+ case LDKClosureReason_CooperativeClosure: {
+ return (*env)->NewObject(env, LDKClosureReason_CooperativeClosure_class, LDKClosureReason_CooperativeClosure_meth);
+ }
+ case LDKClosureReason_CommitmentTxConfirmed: {
+ return (*env)->NewObject(env, LDKClosureReason_CommitmentTxConfirmed_class, LDKClosureReason_CommitmentTxConfirmed_meth);
+ }
+ case LDKClosureReason_ProcessingError: {
+ LDKStr err_str = obj->processing_error.err;
+ jstring err_conv = str_ref_to_java(env, err_str.chars, err_str.len);
+ return (*env)->NewObject(env, LDKClosureReason_ProcessingError_class, LDKClosureReason_ProcessingError_meth, err_conv);
+ }
+ case LDKClosureReason_DisconnectedPeer: {
+ return (*env)->NewObject(env, LDKClosureReason_DisconnectedPeer_class, LDKClosureReason_DisconnectedPeer_meth);
+ }
+ case LDKClosureReason_OutdatedChannelManager: {
+ return (*env)->NewObject(env, LDKClosureReason_OutdatedChannelManager_class, LDKClosureReason_OutdatedChannelManager_meth);
+ }
+ default: abort();
+ }
+}
+static jclass LDKCOption_ClosureReasonZ_Some_class = NULL;
+static jmethodID LDKCOption_ClosureReasonZ_Some_meth = NULL;
+static jclass LDKCOption_ClosureReasonZ_None_class = NULL;
+static jmethodID LDKCOption_ClosureReasonZ_None_meth = NULL;
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKCOption_1ClosureReasonZ_init (JNIEnv *env, jclass clz) {
+ LDKCOption_ClosureReasonZ_Some_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKCOption_ClosureReasonZ$Some;"));
+ CHECK(LDKCOption_ClosureReasonZ_Some_class != NULL);
+ LDKCOption_ClosureReasonZ_Some_meth = (*env)->GetMethodID(env, LDKCOption_ClosureReasonZ_Some_class, "<init>", "(J)V");
+ CHECK(LDKCOption_ClosureReasonZ_Some_meth != NULL);
+ LDKCOption_ClosureReasonZ_None_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKCOption_ClosureReasonZ$None;"));
+ CHECK(LDKCOption_ClosureReasonZ_None_class != NULL);
+ LDKCOption_ClosureReasonZ_None_meth = (*env)->GetMethodID(env, LDKCOption_ClosureReasonZ_None_class, "<init>", "()V");
+ CHECK(LDKCOption_ClosureReasonZ_None_meth != NULL);
+}
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1ClosureReasonZ_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
+ LDKCOption_ClosureReasonZ *obj = (LDKCOption_ClosureReasonZ*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKCOption_ClosureReasonZ_Some: {
+ uint64_t some_ref = ((uint64_t)&obj->some) | 1;
+ return (*env)->NewObject(env, LDKCOption_ClosureReasonZ_Some_class, LDKCOption_ClosureReasonZ_Some_meth, some_ref);
+ }
+ case LDKCOption_ClosureReasonZ_None: {
+ return (*env)->NewObject(env, LDKCOption_ClosureReasonZ_None_class, LDKCOption_ClosureReasonZ_None_meth);
+ }
+ default: abort();
+ }
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1ClosureReasonZDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ *val = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(arg & ~1);
+ CHECK(val->result_ok);
+ uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
+ return res_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1ClosureReasonZDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ *val = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(arg & ~1);
+ CHECK(!val->result_ok);
+ LDKDecodeError err_var = (*val->contents.err);
+ uint64_t err_ref = 0;
+ CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
+ err_ref = (uint64_t)err_var.inner & ~1;
+ return err_ref;
+}
static jclass LDKNetworkUpdate_ChannelUpdateMessage_class = NULL;
static jmethodID LDKNetworkUpdate_ChannelUpdateMessage_meth = NULL;
static jclass LDKNetworkUpdate_ChannelClosed_class = NULL;
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKNetworkUpdate_ChannelUpdateMessage_class, LDKNetworkUpdate_ChannelUpdateMessage_meth, msg_ref);
}
uint64_t outpoint_ref = 0;
CHECK((((uint64_t)outpoint_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&outpoint_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_var);
outpoint_ref = (uint64_t)outpoint_var.inner & ~1;
uint64_t output_ref = ((uint64_t)&obj->static_output.output) | 1;
return (*env)->NewObject(env, LDKSpendableOutputDescriptor_StaticOutput_class, LDKSpendableOutputDescriptor_StaticOutput_meth, outpoint_ref, (uint64_t)output_ref);
uint64_t delayed_payment_output_ref = 0;
CHECK((((uint64_t)delayed_payment_output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&delayed_payment_output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(delayed_payment_output_var);
delayed_payment_output_ref = (uint64_t)delayed_payment_output_var.inner & ~1;
return (*env)->NewObject(env, LDKSpendableOutputDescriptor_DelayedPaymentOutput_class, LDKSpendableOutputDescriptor_DelayedPaymentOutput_meth, delayed_payment_output_ref);
}
uint64_t static_payment_output_ref = 0;
CHECK((((uint64_t)static_payment_output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&static_payment_output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(static_payment_output_var);
static_payment_output_ref = (uint64_t)static_payment_output_var.inner & ~1;
return (*env)->NewObject(env, LDKSpendableOutputDescriptor_StaticPaymentOutput_class, LDKSpendableOutputDescriptor_StaticPaymentOutput_meth, static_payment_output_ref);
}
default: abort();
}
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1SpendableOutputDescriptorZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_SpendableOutputDescriptorZ *ret = MALLOC(sizeof(LDKCVec_SpendableOutputDescriptorZ), "LDKCVec_SpendableOutputDescriptorZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKSpendableOutputDescriptor) * ret->datalen, "LDKCVec_SpendableOutputDescriptorZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKSpendableOutputDescriptor arr_elem_conv = *(LDKSpendableOutputDescriptor*)(arr_elem_ptr);
- arr_elem_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_SpendableOutputDescriptorZ CVec_SpendableOutputDescriptorZ_clone(const LDKCVec_SpendableOutputDescriptorZ *orig) {
LDKCVec_SpendableOutputDescriptorZ ret = { .data = MALLOC(sizeof(LDKSpendableOutputDescriptor) * orig->datalen, "LDKCVec_SpendableOutputDescriptorZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
+static jclass LDKPaymentPurpose_InvoicePayment_class = NULL;
+static jmethodID LDKPaymentPurpose_InvoicePayment_meth = NULL;
+static jclass LDKPaymentPurpose_SpontaneousPayment_class = NULL;
+static jmethodID LDKPaymentPurpose_SpontaneousPayment_meth = NULL;
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKPaymentPurpose_init (JNIEnv *env, jclass clz) {
+ LDKPaymentPurpose_InvoicePayment_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKPaymentPurpose$InvoicePayment;"));
+ CHECK(LDKPaymentPurpose_InvoicePayment_class != NULL);
+ LDKPaymentPurpose_InvoicePayment_meth = (*env)->GetMethodID(env, LDKPaymentPurpose_InvoicePayment_class, "<init>", "([B[BJ)V");
+ CHECK(LDKPaymentPurpose_InvoicePayment_meth != NULL);
+ LDKPaymentPurpose_SpontaneousPayment_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKPaymentPurpose$SpontaneousPayment;"));
+ CHECK(LDKPaymentPurpose_SpontaneousPayment_class != NULL);
+ LDKPaymentPurpose_SpontaneousPayment_meth = (*env)->GetMethodID(env, LDKPaymentPurpose_SpontaneousPayment_class, "<init>", "([B)V");
+ CHECK(LDKPaymentPurpose_SpontaneousPayment_meth != NULL);
+}
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKPaymentPurpose_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
+ LDKPaymentPurpose *obj = (LDKPaymentPurpose*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKPaymentPurpose_InvoicePayment: {
+ int8_tArray payment_preimage_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, payment_preimage_arr, 0, 32, obj->invoice_payment.payment_preimage.data);
+ int8_tArray payment_secret_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, payment_secret_arr, 0, 32, obj->invoice_payment.payment_secret.data);
+ return (*env)->NewObject(env, LDKPaymentPurpose_InvoicePayment_class, LDKPaymentPurpose_InvoicePayment_meth, payment_preimage_arr, payment_secret_arr, obj->invoice_payment.user_payment_id);
+ }
+ case LDKPaymentPurpose_SpontaneousPayment: {
+ int8_tArray spontaneous_payment_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, spontaneous_payment_arr, 0, 32, obj->spontaneous_payment.data);
+ return (*env)->NewObject(env, LDKPaymentPurpose_SpontaneousPayment_class, LDKPaymentPurpose_SpontaneousPayment_meth, spontaneous_payment_arr);
+ }
+ default: abort();
+ }
+}
+static jclass LDKEvent_FundingGenerationReady_class = NULL;
+static jmethodID LDKEvent_FundingGenerationReady_meth = NULL;
+static jclass LDKEvent_PaymentReceived_class = NULL;
+static jmethodID LDKEvent_PaymentReceived_meth = NULL;
+static jclass LDKEvent_PaymentSent_class = NULL;
+static jmethodID LDKEvent_PaymentSent_meth = NULL;
+static jclass LDKEvent_PaymentPathFailed_class = NULL;
+static jmethodID LDKEvent_PaymentPathFailed_meth = NULL;
+static jclass LDKEvent_PendingHTLCsForwardable_class = NULL;
+static jmethodID LDKEvent_PendingHTLCsForwardable_meth = NULL;
+static jclass LDKEvent_SpendableOutputs_class = NULL;
+static jmethodID LDKEvent_SpendableOutputs_meth = NULL;
+static jclass LDKEvent_PaymentForwarded_class = NULL;
+static jmethodID LDKEvent_PaymentForwarded_meth = NULL;
+static jclass LDKEvent_ChannelClosed_class = NULL;
+static jmethodID LDKEvent_ChannelClosed_meth = NULL;
+static jclass LDKEvent_DiscardFunding_class = NULL;
+static jmethodID LDKEvent_DiscardFunding_meth = NULL;
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKEvent_init (JNIEnv *env, jclass clz) {
+ LDKEvent_FundingGenerationReady_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$FundingGenerationReady;"));
+ CHECK(LDKEvent_FundingGenerationReady_class != NULL);
+ LDKEvent_FundingGenerationReady_meth = (*env)->GetMethodID(env, LDKEvent_FundingGenerationReady_class, "<init>", "([BJ[BJ)V");
+ CHECK(LDKEvent_FundingGenerationReady_meth != NULL);
+ LDKEvent_PaymentReceived_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PaymentReceived;"));
+ CHECK(LDKEvent_PaymentReceived_class != NULL);
+ LDKEvent_PaymentReceived_meth = (*env)->GetMethodID(env, LDKEvent_PaymentReceived_class, "<init>", "([BJJ)V");
+ CHECK(LDKEvent_PaymentReceived_meth != NULL);
+ LDKEvent_PaymentSent_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PaymentSent;"));
+ CHECK(LDKEvent_PaymentSent_class != NULL);
+ LDKEvent_PaymentSent_meth = (*env)->GetMethodID(env, LDKEvent_PaymentSent_class, "<init>", "([B[B[BJ)V");
+ CHECK(LDKEvent_PaymentSent_meth != NULL);
+ LDKEvent_PaymentPathFailed_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PaymentPathFailed;"));
+ CHECK(LDKEvent_PaymentPathFailed_class != NULL);
+ LDKEvent_PaymentPathFailed_meth = (*env)->GetMethodID(env, LDKEvent_PaymentPathFailed_class, "<init>", "([B[BZJZ[JJJ)V");
+ CHECK(LDKEvent_PaymentPathFailed_meth != NULL);
+ LDKEvent_PendingHTLCsForwardable_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PendingHTLCsForwardable;"));
+ CHECK(LDKEvent_PendingHTLCsForwardable_class != NULL);
+ LDKEvent_PendingHTLCsForwardable_meth = (*env)->GetMethodID(env, LDKEvent_PendingHTLCsForwardable_class, "<init>", "(J)V");
+ CHECK(LDKEvent_PendingHTLCsForwardable_meth != NULL);
+ LDKEvent_SpendableOutputs_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$SpendableOutputs;"));
+ CHECK(LDKEvent_SpendableOutputs_class != NULL);
+ LDKEvent_SpendableOutputs_meth = (*env)->GetMethodID(env, LDKEvent_SpendableOutputs_class, "<init>", "([J)V");
+ CHECK(LDKEvent_SpendableOutputs_meth != NULL);
+ LDKEvent_PaymentForwarded_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PaymentForwarded;"));
+ CHECK(LDKEvent_PaymentForwarded_class != NULL);
+ LDKEvent_PaymentForwarded_meth = (*env)->GetMethodID(env, LDKEvent_PaymentForwarded_class, "<init>", "(JZ)V");
+ CHECK(LDKEvent_PaymentForwarded_meth != NULL);
+ LDKEvent_ChannelClosed_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$ChannelClosed;"));
+ CHECK(LDKEvent_ChannelClosed_class != NULL);
+ LDKEvent_ChannelClosed_meth = (*env)->GetMethodID(env, LDKEvent_ChannelClosed_class, "<init>", "([BJJ)V");
+ CHECK(LDKEvent_ChannelClosed_meth != NULL);
+ LDKEvent_DiscardFunding_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$DiscardFunding;"));
+ CHECK(LDKEvent_DiscardFunding_class != NULL);
+ LDKEvent_DiscardFunding_meth = (*env)->GetMethodID(env, LDKEvent_DiscardFunding_class, "<init>", "([B[B)V");
+ CHECK(LDKEvent_DiscardFunding_meth != NULL);
+}
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKEvent_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
+ LDKEvent *obj = (LDKEvent*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKEvent_FundingGenerationReady: {
+ int8_tArray temporary_channel_id_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, temporary_channel_id_arr, 0, 32, obj->funding_generation_ready.temporary_channel_id.data);
+ LDKCVec_u8Z output_script_var = obj->funding_generation_ready.output_script;
+ int8_tArray output_script_arr = (*env)->NewByteArray(env, output_script_var.datalen);
+ (*env)->SetByteArrayRegion(env, output_script_arr, 0, output_script_var.datalen, output_script_var.data);
+ return (*env)->NewObject(env, LDKEvent_FundingGenerationReady_class, LDKEvent_FundingGenerationReady_meth, temporary_channel_id_arr, obj->funding_generation_ready.channel_value_satoshis, output_script_arr, obj->funding_generation_ready.user_channel_id);
+ }
+ case LDKEvent_PaymentReceived: {
+ int8_tArray payment_hash_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, payment_hash_arr, 0, 32, obj->payment_received.payment_hash.data);
+ uint64_t purpose_ref = ((uint64_t)&obj->payment_received.purpose) | 1;
+ return (*env)->NewObject(env, LDKEvent_PaymentReceived_class, LDKEvent_PaymentReceived_meth, payment_hash_arr, obj->payment_received.amt, purpose_ref);
+ }
+ case LDKEvent_PaymentSent: {
+ int8_tArray payment_id_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, payment_id_arr, 0, 32, obj->payment_sent.payment_id.data);
+ int8_tArray payment_preimage_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, payment_preimage_arr, 0, 32, obj->payment_sent.payment_preimage.data);
+ int8_tArray payment_hash_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, payment_hash_arr, 0, 32, obj->payment_sent.payment_hash.data);
+ uint64_t fee_paid_msat_ref = ((uint64_t)&obj->payment_sent.fee_paid_msat) | 1;
+ return (*env)->NewObject(env, LDKEvent_PaymentSent_class, LDKEvent_PaymentSent_meth, payment_id_arr, payment_preimage_arr, payment_hash_arr, fee_paid_msat_ref);
+ }
+ case LDKEvent_PaymentPathFailed: {
+ int8_tArray payment_id_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, payment_id_arr, 0, 32, obj->payment_path_failed.payment_id.data);
+ int8_tArray payment_hash_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, payment_hash_arr, 0, 32, obj->payment_path_failed.payment_hash.data);
+ uint64_t network_update_ref = ((uint64_t)&obj->payment_path_failed.network_update) | 1;
+ LDKCVec_RouteHopZ path_var = obj->payment_path_failed.path;
+ int64_tArray path_arr = NULL;
+ path_arr = (*env)->NewLongArray(env, path_var.datalen);
+ int64_t *path_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, path_arr, NULL);
+ for (size_t k = 0; k < path_var.datalen; k++) {
+ LDKRouteHop path_conv_10_var = path_var.data[k];
+ uint64_t path_conv_10_ref = 0;
+ CHECK((((uint64_t)path_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&path_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
+ path_conv_10_ref = (uint64_t)path_conv_10_var.inner & ~1;
+ path_arr_ptr[k] = path_conv_10_ref;
+ }
+ (*env)->ReleasePrimitiveArrayCritical(env, path_arr, path_arr_ptr, 0);
+ uint64_t short_channel_id_ref = ((uint64_t)&obj->payment_path_failed.short_channel_id) | 1;
+ LDKRouteParameters retry_var = obj->payment_path_failed.retry;
+ uint64_t retry_ref = 0;
+ if ((uint64_t)retry_var.inner > 4096) {
+ CHECK((((uint64_t)retry_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&retry_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(retry_var);
+ retry_ref = (uint64_t)retry_var.inner & ~1;
+ }
+ return (*env)->NewObject(env, LDKEvent_PaymentPathFailed_class, LDKEvent_PaymentPathFailed_meth, payment_id_arr, payment_hash_arr, obj->payment_path_failed.rejected_by_dest, network_update_ref, obj->payment_path_failed.all_paths_failed, path_arr, short_channel_id_ref, retry_ref);
+ }
+ case LDKEvent_PendingHTLCsForwardable: {
+ return (*env)->NewObject(env, LDKEvent_PendingHTLCsForwardable_class, LDKEvent_PendingHTLCsForwardable_meth, obj->pending_htl_cs_forwardable.time_forwardable);
+ }
+ case LDKEvent_SpendableOutputs: {
+ LDKCVec_SpendableOutputDescriptorZ outputs_var = obj->spendable_outputs.outputs;
+ int64_tArray outputs_arr = NULL;
+ outputs_arr = (*env)->NewLongArray(env, outputs_var.datalen);
+ int64_t *outputs_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, outputs_arr, NULL);
+ for (size_t b = 0; b < outputs_var.datalen; b++) {
+ uint64_t outputs_conv_27_ref = ((uint64_t)&outputs_var.data[b]) | 1;
+ outputs_arr_ptr[b] = outputs_conv_27_ref;
+ }
+ (*env)->ReleasePrimitiveArrayCritical(env, outputs_arr, outputs_arr_ptr, 0);
+ return (*env)->NewObject(env, LDKEvent_SpendableOutputs_class, LDKEvent_SpendableOutputs_meth, outputs_arr);
+ }
+ case LDKEvent_PaymentForwarded: {
+ uint64_t fee_earned_msat_ref = ((uint64_t)&obj->payment_forwarded.fee_earned_msat) | 1;
+ return (*env)->NewObject(env, LDKEvent_PaymentForwarded_class, LDKEvent_PaymentForwarded_meth, fee_earned_msat_ref, obj->payment_forwarded.claim_from_onchain_tx);
+ }
+ case LDKEvent_ChannelClosed: {
+ int8_tArray channel_id_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, channel_id_arr, 0, 32, obj->channel_closed.channel_id.data);
+ uint64_t reason_ref = ((uint64_t)&obj->channel_closed.reason) | 1;
+ return (*env)->NewObject(env, LDKEvent_ChannelClosed_class, LDKEvent_ChannelClosed_meth, channel_id_arr, obj->channel_closed.user_channel_id, reason_ref);
+ }
+ case LDKEvent_DiscardFunding: {
+ int8_tArray channel_id_arr = (*env)->NewByteArray(env, 32);
+ (*env)->SetByteArrayRegion(env, channel_id_arr, 0, 32, obj->discard_funding.channel_id.data);
+ LDKTransaction transaction_var = obj->discard_funding.transaction;
+ int8_tArray transaction_arr = (*env)->NewByteArray(env, transaction_var.datalen);
+ (*env)->SetByteArrayRegion(env, transaction_arr, 0, transaction_var.datalen, transaction_var.data);
+ return (*env)->NewObject(env, LDKEvent_DiscardFunding_class, LDKEvent_DiscardFunding_meth, channel_id_arr, transaction_arr);
+ }
+ default: abort();
+ }
+}
+static jclass LDKCOption_EventZ_Some_class = NULL;
+static jmethodID LDKCOption_EventZ_Some_meth = NULL;
+static jclass LDKCOption_EventZ_None_class = NULL;
+static jmethodID LDKCOption_EventZ_None_meth = NULL;
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKCOption_1EventZ_init (JNIEnv *env, jclass clz) {
+ LDKCOption_EventZ_Some_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKCOption_EventZ$Some;"));
+ CHECK(LDKCOption_EventZ_Some_class != NULL);
+ LDKCOption_EventZ_Some_meth = (*env)->GetMethodID(env, LDKCOption_EventZ_Some_class, "<init>", "(J)V");
+ CHECK(LDKCOption_EventZ_Some_meth != NULL);
+ LDKCOption_EventZ_None_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKCOption_EventZ$None;"));
+ CHECK(LDKCOption_EventZ_None_class != NULL);
+ LDKCOption_EventZ_None_meth = (*env)->GetMethodID(env, LDKCOption_EventZ_None_class, "<init>", "()V");
+ CHECK(LDKCOption_EventZ_None_meth != NULL);
+}
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1EventZ_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
+ LDKCOption_EventZ *obj = (LDKCOption_EventZ*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKCOption_EventZ_Some: {
+ uint64_t some_ref = ((uint64_t)&obj->some) | 1;
+ return (*env)->NewObject(env, LDKCOption_EventZ_Some_class, LDKCOption_EventZ_Some_meth, some_ref);
+ }
+ case LDKCOption_EventZ_None: {
+ return (*env)->NewObject(env, LDKCOption_EventZ_None_class, LDKCOption_EventZ_None_meth);
+ }
+ default: abort();
+ }
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1EventZDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_EventZDecodeErrorZ *val = (LDKCResult_COption_EventZDecodeErrorZ*)(arg & ~1);
+ CHECK(val->result_ok);
+ uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
+ return res_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1EventZDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_EventZDecodeErrorZ *val = (LDKCResult_COption_EventZDecodeErrorZ*)(arg & ~1);
+ CHECK(!val->result_ok);
+ LDKDecodeError err_var = (*val->contents.err);
+ uint64_t err_ref = 0;
+ CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
+ err_ref = (uint64_t)err_var.inner & ~1;
+ return err_ref;
+}
static jclass LDKErrorAction_DisconnectPeer_class = NULL;
static jmethodID LDKErrorAction_DisconnectPeer_meth = NULL;
static jclass LDKErrorAction_IgnoreError_class = NULL;
if ((uint64_t)msg_var.inner > 4096) {
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
}
return (*env)->NewObject(env, LDKErrorAction_DisconnectPeer_class, LDKErrorAction_DisconnectPeer_meth, msg_ref);
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKErrorAction_SendErrorMessage_class, LDKErrorAction_SendErrorMessage_meth, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendAcceptChannel_class, LDKMessageSendEvent_SendAcceptChannel_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendOpenChannel_class, LDKMessageSendEvent_SendOpenChannel_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendFundingCreated_class, LDKMessageSendEvent_SendFundingCreated_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendFundingSigned_class, LDKMessageSendEvent_SendFundingSigned_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendFundingLocked_class, LDKMessageSendEvent_SendFundingLocked_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendAnnouncementSignatures_class, LDKMessageSendEvent_SendAnnouncementSignatures_meth, node_id_arr, msg_ref);
}
uint64_t updates_ref = 0;
CHECK((((uint64_t)updates_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&updates_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_var);
updates_ref = (uint64_t)updates_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_UpdateHTLCs_class, LDKMessageSendEvent_UpdateHTLCs_meth, node_id_arr, updates_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendRevokeAndACK_class, LDKMessageSendEvent_SendRevokeAndACK_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendClosingSigned_class, LDKMessageSendEvent_SendClosingSigned_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendShutdown_class, LDKMessageSendEvent_SendShutdown_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendChannelReestablish_class, LDKMessageSendEvent_SendChannelReestablish_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
LDKChannelUpdate update_msg_var = obj->broadcast_channel_announcement.update_msg;
uint64_t update_msg_ref = 0;
CHECK((((uint64_t)update_msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_var);
update_msg_ref = (uint64_t)update_msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_BroadcastChannelAnnouncement_class, LDKMessageSendEvent_BroadcastChannelAnnouncement_meth, msg_ref, update_msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_BroadcastNodeAnnouncement_class, LDKMessageSendEvent_BroadcastNodeAnnouncement_meth, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_BroadcastChannelUpdate_class, LDKMessageSendEvent_BroadcastChannelUpdate_meth, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendChannelUpdate_class, LDKMessageSendEvent_SendChannelUpdate_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendChannelRangeQuery_class, LDKMessageSendEvent_SendChannelRangeQuery_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendShortIdsQuery_class, LDKMessageSendEvent_SendShortIdsQuery_meth, node_id_arr, msg_ref);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return (*env)->NewObject(env, LDKMessageSendEvent_SendReplyChannelRange_class, LDKMessageSendEvent_SendReplyChannelRange_meth, node_id_arr, msg_ref);
}
default: abort();
}
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1MessageSendEventZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_MessageSendEventZ *ret = MALLOC(sizeof(LDKCVec_MessageSendEventZ), "LDKCVec_MessageSendEventZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKMessageSendEvent) * ret->datalen, "LDKCVec_MessageSendEventZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKMessageSendEvent arr_elem_conv = *(LDKMessageSendEvent*)(arr_elem_ptr);
- arr_elem_conv = MessageSendEvent_clone((LDKMessageSendEvent*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_MessageSendEventZ CVec_MessageSendEventZ_clone(const LDKCVec_MessageSendEventZ *orig) {
LDKCVec_MessageSendEventZ ret = { .data = MALLOC(sizeof(LDKMessageSendEvent) * orig->datalen, "LDKCVec_MessageSendEventZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_InitFeaturesDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_InitFeaturesDecodeErrorZ *val = (LDKCResult_InitFeaturesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NodeFeaturesDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NodeFeaturesDecodeErrorZ *val = (LDKCResult_NodeFeaturesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ChannelFeaturesDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ChannelFeaturesDecodeErrorZ *val = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceFeaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_InvoiceFeaturesDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceFeaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_InvoiceFeaturesDecodeErrorZ *val = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ScoringParametersDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ScoringParametersDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ScoringParametersDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ScoringParametersDecodeErrorZ *val = (LDKCResult_ScoringParametersDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ScorerDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ScorerDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ScorerDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ScorerDecodeErrorZ *val = (LDKCResult_ScorerDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *val = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *val = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SpendableOutputDescriptorDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SpendableOutputDescriptorDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_SpendableOutputDescriptorDecodeErrorZ *val = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NoneNoneZ*)arg)->result_ok;
-}
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NoneNoneZ *val = (LDKCResult_NoneNoneZ*)(arg & ~1);
CHECK(val->result_ok);
return ret_arr;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *val = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(arg & ~1);
CHECK(val->result_ok);
CHECK(!val->result_ok);
return *val->contents.err;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignatureNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_SignatureNoneZ*)arg)->result_ok;
-}
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignatureNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_SignatureNoneZ *val = (LDKCResult_SignatureNoneZ*)(arg & ~1);
CHECK(val->result_ok);
holder_tx_var = HolderCommitmentTransaction_clone(holder_tx);
CHECK((((uint64_t)holder_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&holder_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_tx_var);
holder_tx_ref = (uint64_t)holder_tx_var.inner;
if (holder_tx_var.is_owned) {
holder_tx_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
- ret_conv = CResult_NoneNoneZ_clone((LDKCResult_NoneNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
commitment_tx_var = CommitmentTransaction_clone(commitment_tx);
CHECK((((uint64_t)commitment_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&commitment_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_var);
commitment_tx_ref = (uint64_t)commitment_tx_var.inner;
if (commitment_tx_var.is_owned) {
commitment_tx_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(ret_ptr);
- ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
- ret_conv = CResult_NoneNoneZ_clone((LDKCResult_NoneNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
commitment_tx_var = HolderCommitmentTransaction_clone(commitment_tx);
CHECK((((uint64_t)commitment_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&commitment_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_var);
commitment_tx_ref = (uint64_t)commitment_tx_var.inner;
if (commitment_tx_var.is_owned) {
commitment_tx_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(ret_ptr);
- ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
htlc_var = HTLCOutputInCommitment_clone(htlc);
CHECK((((uint64_t)htlc_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&htlc_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_var);
htlc_ref = (uint64_t)htlc_var.inner;
if (htlc_var.is_owned) {
htlc_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
htlc_var = HTLCOutputInCommitment_clone(htlc);
CHECK((((uint64_t)htlc_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&htlc_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_var);
htlc_ref = (uint64_t)htlc_var.inner;
if (htlc_var.is_owned) {
htlc_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
closing_tx_var = ClosingTransaction_clone(closing_tx);
CHECK((((uint64_t)closing_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&closing_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(closing_tx_var);
closing_tx_ref = (uint64_t)closing_tx_var.inner;
if (closing_tx_var.is_owned) {
closing_tx_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
msg_var = UnsignedChannelAnnouncement_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
channel_parameters_var = ChannelTransactionParameters_clone(channel_parameters);
CHECK((((uint64_t)channel_parameters_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&channel_parameters_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_var);
channel_parameters_ref = (uint64_t)channel_parameters_var.inner;
if (channel_parameters_var.is_owned) {
channel_parameters_ref |= 1;
LDKChannelPublicKeys pubkeys_conv;
pubkeys_conv.inner = (void*)(pubkeys & (~1));
pubkeys_conv.is_owned = (pubkeys & 1) || (pubkeys == 0);
- pubkeys_conv = ChannelPublicKeys_clone(&pubkeys_conv);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_conv);
LDKBaseSign ret = {
.this_arg = (void*) calls,
LDKHolderCommitmentTransaction holder_tx_conv;
holder_tx_conv.inner = (void*)(holder_tx & (~1));
holder_tx_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_tx_conv);
LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
*ret_conv = (this_arg_conv->validate_holder_commitment)(this_arg_conv->this_arg, &holder_tx_conv);
return (uint64_t)ret_conv;
LDKCommitmentTransaction commitment_tx_conv;
commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
commitment_tx_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
*ret_conv = (this_arg_conv->sign_counterparty_commitment)(this_arg_conv->this_arg, &commitment_tx_conv);
return (uint64_t)ret_conv;
LDKHolderCommitmentTransaction commitment_tx_conv;
commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
commitment_tx_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
*ret_conv = (this_arg_conv->sign_holder_commitment_and_htlcs)(this_arg_conv->this_arg, &commitment_tx_conv);
return (uint64_t)ret_conv;
LDKHTLCOutputInCommitment htlc_conv;
htlc_conv.inner = (void*)(htlc & (~1));
htlc_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
*ret_conv = (this_arg_conv->sign_justice_revoked_htlc)(this_arg_conv->this_arg, justice_tx_ref, input, amount, per_commitment_key_ref, &htlc_conv);
return (uint64_t)ret_conv;
LDKHTLCOutputInCommitment htlc_conv;
htlc_conv.inner = (void*)(htlc & (~1));
htlc_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
*ret_conv = (this_arg_conv->sign_counterparty_htlc_transaction)(this_arg_conv->this_arg, htlc_tx_ref, input, amount, per_commitment_point_ref, &htlc_conv);
return (uint64_t)ret_conv;
LDKClosingTransaction closing_tx_conv;
closing_tx_conv.inner = (void*)(closing_tx & (~1));
closing_tx_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(closing_tx_conv);
LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
*ret_conv = (this_arg_conv->sign_closing_transaction)(this_arg_conv->this_arg, &closing_tx_conv);
return (uint64_t)ret_conv;
LDKUnsignedChannelAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
*ret_conv = (this_arg_conv->sign_channel_announcement)(this_arg_conv->this_arg, &msg_conv);
return (uint64_t)ret_conv;
LDKChannelTransactionParameters channel_parameters_conv;
channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
channel_parameters_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
(this_arg_conv->ready_channel)(this_arg_conv->this_arg, &channel_parameters_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelPublicKeys pubkeys_conv;
pubkeys_conv.inner = (void*)(pubkeys & (~1));
pubkeys_conv.is_owned = (pubkeys & 1) || (pubkeys == 0);
- pubkeys_conv = ChannelPublicKeys_clone(&pubkeys_conv);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_conv);
LDKSign ret = {
.this_arg = (void*) calls,
return ret_arr;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_SignDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_SignDecodeErrorZ *val = (LDKCResult_SignDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RecoverableSignatureNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_RecoverableSignatureNoneZ*)arg)->result_ok;
-}
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RecoverableSignatureNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_RecoverableSignatureNoneZ *val = (LDKCResult_RecoverableSignatureNoneZ*)(arg & ~1);
CHECK(val->result_ok);
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1CVec_1u8ZZNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_CVec_CVec_u8ZZNoneZ*)arg)->result_ok;
-}
JNIEXPORT jobjectArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1CVec_1u8ZZNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_CVec_CVec_u8ZZNoneZ *val = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(arg & ~1);
CHECK(val->result_ok);
CHECK(!val->result_ok);
return *val->contents.err;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InMemorySignerDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_InMemorySignerDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InMemorySignerDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_InMemorySignerDecodeErrorZ *val = (LDKCResult_InMemorySignerDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1TxOutZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_TxOutZ *ret = MALLOC(sizeof(LDKCVec_TxOutZ), "LDKCVec_TxOutZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKTxOut) * ret->datalen, "LDKCVec_TxOutZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKTxOut arr_elem_conv = *(LDKTxOut*)(arr_elem_ptr);
- arr_elem_conv = TxOut_clone((LDKTxOut*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_TxOutZ CVec_TxOutZ_clone(const LDKCVec_TxOutZ *orig) {
LDKCVec_TxOutZ ret = { .data = MALLOC(sizeof(LDKTxOut) * orig->datalen, "LDKCVec_TxOutZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TransactionNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_TransactionNoneZ*)arg)->result_ok;
-}
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TransactionNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_TransactionNoneZ *val = (LDKCResult_TransactionNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1BlockHashChannelMonitorZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_C2Tuple_BlockHashChannelMonitorZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ), "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ) * ret->datalen, "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_BlockHashChannelMonitorZ arr_elem_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_BlockHashChannelMonitorZ_clone((LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_BlockHashChannelMonitorZZ CVec_C2Tuple_BlockHashChannelMonitorZZ_clone(const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ *orig) {
LDKCVec_C2Tuple_BlockHashChannelMonitorZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ) * orig->datalen, "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ *val = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t script_ref = 0;
CHECK((((uint64_t)script_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&script_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(script_var);
script_ref = (uint64_t)script_var.inner & ~1;
return (*env)->NewObject(env, LDKAPIError_IncompatibleShutdownScript_class, LDKAPIError_IncompatibleShutdownScript_meth, script_ref);
}
default: abort();
}
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneAPIErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NoneAPIErrorZ*)arg)->result_ok;
-}
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneAPIErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NoneAPIErrorZ *val = (LDKCResult_NoneAPIErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
return err_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1CResult_1NoneAPIErrorZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_CResult_NoneAPIErrorZZ *ret = MALLOC(sizeof(LDKCVec_CResult_NoneAPIErrorZZ), "LDKCVec_CResult_NoneAPIErrorZZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ) * ret->datalen, "LDKCVec_CResult_NoneAPIErrorZZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKCResult_NoneAPIErrorZ arr_elem_conv = *(LDKCResult_NoneAPIErrorZ*)(arr_elem_ptr);
- arr_elem_conv = CResult_NoneAPIErrorZ_clone((LDKCResult_NoneAPIErrorZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_CResult_NoneAPIErrorZZ CVec_CResult_NoneAPIErrorZZ_clone(const LDKCVec_CResult_NoneAPIErrorZZ *orig) {
LDKCVec_CResult_NoneAPIErrorZZ ret = { .data = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ) * orig->datalen, "LDKCVec_CResult_NoneAPIErrorZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1APIErrorZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_APIErrorZ *ret = MALLOC(sizeof(LDKCVec_APIErrorZ), "LDKCVec_APIErrorZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKAPIError) * ret->datalen, "LDKCVec_APIErrorZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKAPIError arr_elem_conv = *(LDKAPIError*)(arr_elem_ptr);
- arr_elem_conv = APIError_clone((LDKAPIError*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_APIErrorZ CVec_APIErrorZ_clone(const LDKCVec_APIErrorZ *orig) {
LDKCVec_APIErrorZ ret = { .data = MALLOC(sizeof(LDKAPIError) * orig->datalen, "LDKCVec_APIErrorZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1_1u832APIErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult__u832APIErrorZ*)arg)->result_ok;
-}
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1_1u832APIErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult__u832APIErrorZ *val = (LDKCResult__u832APIErrorZ*)(arg & ~1);
CHECK(val->result_ok);
if ((uint64_t)failed_paths_retry_var.inner > 4096) {
CHECK((((uint64_t)failed_paths_retry_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&failed_paths_retry_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(failed_paths_retry_var);
failed_paths_retry_ref = (uint64_t)failed_paths_retry_var.inner & ~1;
}
int8_tArray payment_id_arr = (*env)->NewByteArray(env, 32);
default: abort();
}
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PaymentIdPaymentSendFailureZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_PaymentIdPaymentSendFailureZ*)arg)->result_ok;
-}
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PaymentIdPaymentSendFailureZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_PaymentIdPaymentSendFailureZ *val = (LDKCResult_PaymentIdPaymentSendFailureZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePaymentSendFailureZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NonePaymentSendFailureZ*)arg)->result_ok;
-}
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePaymentSendFailureZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NonePaymentSendFailureZ *val = (LDKCResult_NonePaymentSendFailureZ*)(arg & ~1);
CHECK(val->result_ok);
return ret_arr;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1PaymentHashPaymentIdZPaymentSendFailureZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1PaymentHashPaymentIdZPaymentSendFailureZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *val = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(arg & ~1);
CHECK(val->result_ok);
default: abort();
}
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1NetAddressZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_NetAddressZ *ret = MALLOC(sizeof(LDKCVec_NetAddressZ), "LDKCVec_NetAddressZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKNetAddress) * ret->datalen, "LDKCVec_NetAddressZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKNetAddress arr_elem_conv = *(LDKNetAddress*)(arr_elem_ptr);
- arr_elem_conv = NetAddress_clone((LDKNetAddress*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_NetAddressZ CVec_NetAddressZ_clone(const LDKCVec_NetAddressZ *orig) {
LDKCVec_NetAddressZ ret = { .data = MALLOC(sizeof(LDKNetAddress) * orig->datalen, "LDKCVec_NetAddressZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
return ret_arr;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PaymentSecretAPIErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_PaymentSecretAPIErrorZ*)arg)->result_ok;
-}
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PaymentSecretAPIErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_PaymentSecretAPIErrorZ *val = (LDKCResult_PaymentSecretAPIErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
return err_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1ChannelMonitorZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_ChannelMonitorZ *ret = MALLOC(sizeof(LDKCVec_ChannelMonitorZ), "LDKCVec_ChannelMonitorZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKChannelMonitor) * ret->datalen, "LDKCVec_ChannelMonitorZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKChannelMonitor arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = ChannelMonitor_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_ChannelMonitorZ CVec_ChannelMonitorZ_clone(const LDKCVec_ChannelMonitorZ *orig) {
LDKCVec_ChannelMonitorZ ret = { .data = MALLOC(sizeof(LDKChannelMonitor) * orig->datalen, "LDKCVec_ChannelMonitorZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
uint64_t funding_txo_ref = 0;
CHECK((((uint64_t)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
funding_txo_ref = (uint64_t)funding_txo_var.inner;
if (funding_txo_var.is_owned) {
funding_txo_ref |= 1;
uint64_t monitor_ref = 0;
CHECK((((uint64_t)monitor_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&monitor_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(monitor_var);
monitor_ref = (uint64_t)monitor_var.inner;
if (monitor_var.is_owned) {
monitor_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(ret_ptr);
- ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
uint64_t funding_txo_ref = 0;
CHECK((((uint64_t)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
funding_txo_ref = (uint64_t)funding_txo_var.inner;
if (funding_txo_var.is_owned) {
funding_txo_ref |= 1;
uint64_t update_ref = 0;
CHECK((((uint64_t)update_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_var);
update_ref = (uint64_t)update_var.inner;
if (update_var.is_owned) {
update_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(ret_ptr);
- ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
void* ret_conv_14_ptr = (void*)(((uint64_t)ret_conv_14) & ~1);
CHECK_ACCESS(ret_conv_14_ptr);
LDKMonitorEvent ret_conv_14_conv = *(LDKMonitorEvent*)(ret_conv_14_ptr);
- ret_conv_14_conv = MonitorEvent_clone((LDKMonitorEvent*)(((uint64_t)ret_conv_14) & ~1));
+ FREE((void*)ret_conv_14);
ret_constr.data[o] = ret_conv_14_conv;
}
(*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
LDKOutPoint funding_txo_conv;
funding_txo_conv.inner = (void*)(funding_txo & (~1));
funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
funding_txo_conv = OutPoint_clone(&funding_txo_conv);
LDKChannelMonitor monitor_conv;
monitor_conv.inner = (void*)(monitor & (~1));
monitor_conv.is_owned = (monitor & 1) || (monitor == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(monitor_conv);
monitor_conv = ChannelMonitor_clone(&monitor_conv);
LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
*ret_conv = (this_arg_conv->watch_channel)(this_arg_conv->this_arg, funding_txo_conv, monitor_conv);
LDKOutPoint funding_txo_conv;
funding_txo_conv.inner = (void*)(funding_txo & (~1));
funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
funding_txo_conv = OutPoint_clone(&funding_txo_conv);
LDKChannelMonitorUpdate update_conv;
update_conv.inner = (void*)(update & (~1));
update_conv.is_owned = (update & 1) || (update == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_conv);
update_conv = ChannelMonitorUpdate_clone(&update_conv);
LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
*ret_conv = (this_arg_conv->update_channel)(this_arg_conv->this_arg, funding_txo_conv, update_conv);
LDKShutdownScript ret_conv;
ret_conv.inner = (void*)(ret & (~1));
ret_conv.is_owned = (ret & 1) || (ret == 0);
- ret_conv = ShutdownScript_clone(&ret_conv);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKSign ret_conv = *(LDKSign*)(ret_ptr);
- ret_conv = Sign_clone(&ret_conv);
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignDecodeErrorZ ret_conv = *(LDKCResult_SignDecodeErrorZ*)(ret_ptr);
- ret_conv = CResult_SignDecodeErrorZ_clone((LDKCResult_SignDecodeErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_RecoverableSignatureNoneZ ret_conv = *(LDKCResult_RecoverableSignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_RecoverableSignatureNoneZ_clone((LDKCResult_RecoverableSignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
FREE(j_calls);
}
}
-void log_LDKLogger_jcall(const void* this_arg, const char* record) {
+void log_LDKLogger_jcall(const void* this_arg, const LDKRecord * record) {
LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
JNIEnv *env;
jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);
} else {
DO_ASSERT(get_jenv_res == JNI_OK);
}
- const char* record_str = record;
- jstring record_conv = str_ref_to_java(env, record_str, strlen(record_str));
+ LDKRecord record_var = *record;
+ uint64_t record_ref = 0;
+ record_var = Record_clone(record);
+ CHECK((((uint64_t)record_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&record_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(record_var);
+ record_ref = (uint64_t)record_var.inner;
+ if (record_var.is_owned) {
+ record_ref |= 1;
+ }
jobject obj = (*env)->NewLocalRef(env, j_calls->o);
CHECK(obj != NULL);
- (*env)->CallVoidMethod(env, obj, j_calls->log_meth, record_conv);
+ (*env)->CallVoidMethod(env, obj, j_calls->log_meth, record_ref);
if ((*env)->ExceptionCheck(env)) {
(*env)->ExceptionDescribe(env);
(*env)->FatalError(env, "A call to log in LDKLogger from rust threw an exception.");
atomic_init(&calls->refcnt, 1);
DO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);
calls->o = (*env)->NewWeakGlobalRef(env, o);
- calls->log_meth = (*env)->GetMethodID(env, c, "log", "(Ljava/lang/String;)V");
+ calls->log_meth = (*env)->GetMethodID(env, c, "log", "(J)V");
CHECK(calls->log_meth != NULL);
LDKLogger ret = {
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner & ~1;
return ret_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ChannelConfigDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ChannelConfigDecodeErrorZ *val = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OutPointDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_OutPointDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OutPointDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_OutPointDecodeErrorZ *val = (LDKCResult_OutPointDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
default: abort();
}
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1TypeZDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_COption_TypeZDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1TypeZDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_COption_TypeZDecodeErrorZ *val = (LDKCResult_COption_TypeZDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
uint64_t routing_ref = 0;
CHECK((((uint64_t)routing_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&routing_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(routing_var);
routing_ref = (uint64_t)routing_var.inner & ~1;
return (*env)->NewObject(env, LDKPaymentError_Routing_class, LDKPaymentError_Routing_meth, routing_ref);
}
default: abort();
}
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PaymentIdPaymentErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_PaymentIdPaymentErrorZ*)arg)->result_ok;
-}
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PaymentIdPaymentErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_PaymentIdPaymentErrorZ *val = (LDKCResult_PaymentIdPaymentErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SiPrefixNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_SiPrefixNoneZ*)arg)->result_ok;
-}
JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SiPrefixNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_SiPrefixNoneZ *val = (LDKCResult_SiPrefixNoneZ*)(arg & ~1);
CHECK(val->result_ok);
CHECK(!val->result_ok);
return *val->contents.err;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_InvoiceNoneZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_InvoiceNoneZ *val = (LDKCResult_InvoiceNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
CHECK(!val->result_ok);
return *val->contents.err;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignedRawInvoiceNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_SignedRawInvoiceNoneZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignedRawInvoiceNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_SignedRawInvoiceNoneZ *val = (LDKCResult_SignedRawInvoiceNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PayeePubKeyErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_PayeePubKeyErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PayeePubKeyErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_PayeePubKeyErrorZ *val = (LDKCResult_PayeePubKeyErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
jclass err_conv = LDKSecp256k1Error_to_java(env, (*val->contents.err));
return err_conv;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1PrivateRouteZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_PrivateRouteZ *ret = MALLOC(sizeof(LDKCVec_PrivateRouteZ), "LDKCVec_PrivateRouteZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKPrivateRoute) * ret->datalen, "LDKCVec_PrivateRouteZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKPrivateRoute arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = PrivateRoute_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_PrivateRouteZ CVec_PrivateRouteZ_clone(const LDKCVec_PrivateRouteZ *orig) {
LDKCVec_PrivateRouteZ ret = { .data = MALLOC(sizeof(LDKPrivateRoute) * orig->datalen, "LDKCVec_PrivateRouteZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PositiveTimestampCreationErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_PositiveTimestampCreationErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PositiveTimestampCreationErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_PositiveTimestampCreationErrorZ *val = (LDKCResult_PositiveTimestampCreationErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
jclass err_conv = LDKCreationError_to_java(env, (*val->contents.err));
return err_conv;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneSemanticErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NoneSemanticErrorZ*)arg)->result_ok;
-}
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneSemanticErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NoneSemanticErrorZ *val = (LDKCResult_NoneSemanticErrorZ*)(arg & ~1);
CHECK(val->result_ok);
jclass err_conv = LDKSemanticError_to_java(env, (*val->contents.err));
return err_conv;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceSemanticErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_InvoiceSemanticErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceSemanticErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_InvoiceSemanticErrorZ *val = (LDKCResult_InvoiceSemanticErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
jclass err_conv = LDKSemanticError_to_java(env, (*val->contents.err));
return err_conv;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DescriptionCreationErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_DescriptionCreationErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DescriptionCreationErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_DescriptionCreationErrorZ *val = (LDKCResult_DescriptionCreationErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
jclass err_conv = LDKCreationError_to_java(env, (*val->contents.err));
return err_conv;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ExpiryTimeCreationErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ExpiryTimeCreationErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ExpiryTimeCreationErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ExpiryTimeCreationErrorZ *val = (LDKCResult_ExpiryTimeCreationErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
jclass err_conv = LDKCreationError_to_java(env, (*val->contents.err));
return err_conv;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PrivateRouteCreationErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_PrivateRouteCreationErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PrivateRouteCreationErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_PrivateRouteCreationErrorZ *val = (LDKCResult_PrivateRouteCreationErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
jclass err_conv = LDKCreationError_to_java(env, (*val->contents.err));
return err_conv;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1StringErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_StringErrorZ*)arg)->result_ok;
-}
JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_LDKCResult_1StringErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_StringErrorZ *val = (LDKCResult_StringErrorZ*)(arg & ~1);
CHECK(val->result_ok);
jclass err_conv = LDKSecp256k1Error_to_java(env, (*val->contents.err));
return err_conv;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelMonitorUpdateDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelMonitorUpdateDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ChannelMonitorUpdateDecodeErrorZ *val = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCUpdateDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_HTLCUpdateDecodeErrorZ*)arg)->result_ok;
+static jclass LDKCOption_MonitorEventZ_Some_class = NULL;
+static jmethodID LDKCOption_MonitorEventZ_Some_meth = NULL;
+static jclass LDKCOption_MonitorEventZ_None_class = NULL;
+static jmethodID LDKCOption_MonitorEventZ_None_meth = NULL;
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKCOption_1MonitorEventZ_init (JNIEnv *env, jclass clz) {
+ LDKCOption_MonitorEventZ_Some_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKCOption_MonitorEventZ$Some;"));
+ CHECK(LDKCOption_MonitorEventZ_Some_class != NULL);
+ LDKCOption_MonitorEventZ_Some_meth = (*env)->GetMethodID(env, LDKCOption_MonitorEventZ_Some_class, "<init>", "(J)V");
+ CHECK(LDKCOption_MonitorEventZ_Some_meth != NULL);
+ LDKCOption_MonitorEventZ_None_class =
+ (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKCOption_MonitorEventZ$None;"));
+ CHECK(LDKCOption_MonitorEventZ_None_class != NULL);
+ LDKCOption_MonitorEventZ_None_meth = (*env)->GetMethodID(env, LDKCOption_MonitorEventZ_None_class, "<init>", "()V");
+ CHECK(LDKCOption_MonitorEventZ_None_meth != NULL);
+}
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1MonitorEventZ_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
+ LDKCOption_MonitorEventZ *obj = (LDKCOption_MonitorEventZ*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKCOption_MonitorEventZ_Some: {
+ uint64_t some_ref = ((uint64_t)&obj->some) | 1;
+ return (*env)->NewObject(env, LDKCOption_MonitorEventZ_Some_class, LDKCOption_MonitorEventZ_Some_meth, some_ref);
+ }
+ case LDKCOption_MonitorEventZ_None: {
+ return (*env)->NewObject(env, LDKCOption_MonitorEventZ_None_class, LDKCOption_MonitorEventZ_None_meth);
+ }
+ default: abort();
+ }
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1MonitorEventZDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ *val = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(arg & ~1);
+ CHECK(val->result_ok);
+ uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
+ return res_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1MonitorEventZDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ *val = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(arg & ~1);
+ CHECK(!val->result_ok);
+ LDKDecodeError err_var = (*val->contents.err);
+ uint64_t err_ref = 0;
+ CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
+ err_ref = (uint64_t)err_var.inner & ~1;
+ return err_ref;
}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCUpdateDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_HTLCUpdateDecodeErrorZ *val = (LDKCResult_HTLCUpdateDecodeErrorZ*)(arg & ~1);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneMonitorUpdateErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NoneMonitorUpdateErrorZ*)arg)->result_ok;
-}
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneMonitorUpdateErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NoneMonitorUpdateErrorZ *val = (LDKCResult_NoneMonitorUpdateErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_arr;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1u32ScriptZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_C2Tuple_u32ScriptZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_u32ScriptZZ), "LDKCVec_C2Tuple_u32ScriptZZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ) * ret->datalen, "LDKCVec_C2Tuple_u32ScriptZZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_u32ScriptZ arr_elem_conv = *(LDKC2Tuple_u32ScriptZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_u32ScriptZ_clone((LDKC2Tuple_u32ScriptZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_u32ScriptZZ CVec_C2Tuple_u32ScriptZZ_clone(const LDKCVec_C2Tuple_u32ScriptZZ *orig) {
LDKCVec_C2Tuple_u32ScriptZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ) * orig->datalen, "LDKCVec_C2Tuple_u32ScriptZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
return ret_arr;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ) * ret->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ arr_elem_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone((LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_clone(const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ *orig) {
LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ) * orig->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-static jclass LDKPaymentPurpose_InvoicePayment_class = NULL;
-static jmethodID LDKPaymentPurpose_InvoicePayment_meth = NULL;
-static jclass LDKPaymentPurpose_SpontaneousPayment_class = NULL;
-static jmethodID LDKPaymentPurpose_SpontaneousPayment_meth = NULL;
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKPaymentPurpose_init (JNIEnv *env, jclass clz) {
- LDKPaymentPurpose_InvoicePayment_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKPaymentPurpose$InvoicePayment;"));
- CHECK(LDKPaymentPurpose_InvoicePayment_class != NULL);
- LDKPaymentPurpose_InvoicePayment_meth = (*env)->GetMethodID(env, LDKPaymentPurpose_InvoicePayment_class, "<init>", "([B[BJ)V");
- CHECK(LDKPaymentPurpose_InvoicePayment_meth != NULL);
- LDKPaymentPurpose_SpontaneousPayment_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKPaymentPurpose$SpontaneousPayment;"));
- CHECK(LDKPaymentPurpose_SpontaneousPayment_class != NULL);
- LDKPaymentPurpose_SpontaneousPayment_meth = (*env)->GetMethodID(env, LDKPaymentPurpose_SpontaneousPayment_class, "<init>", "([B)V");
- CHECK(LDKPaymentPurpose_SpontaneousPayment_meth != NULL);
-}
-JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKPaymentPurpose_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
- LDKPaymentPurpose *obj = (LDKPaymentPurpose*)(ptr & ~1);
- switch(obj->tag) {
- case LDKPaymentPurpose_InvoicePayment: {
- int8_tArray payment_preimage_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, payment_preimage_arr, 0, 32, obj->invoice_payment.payment_preimage.data);
- int8_tArray payment_secret_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, payment_secret_arr, 0, 32, obj->invoice_payment.payment_secret.data);
- return (*env)->NewObject(env, LDKPaymentPurpose_InvoicePayment_class, LDKPaymentPurpose_InvoicePayment_meth, payment_preimage_arr, payment_secret_arr, obj->invoice_payment.user_payment_id);
- }
- case LDKPaymentPurpose_SpontaneousPayment: {
- int8_tArray spontaneous_payment_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, spontaneous_payment_arr, 0, 32, obj->spontaneous_payment.data);
- return (*env)->NewObject(env, LDKPaymentPurpose_SpontaneousPayment_class, LDKPaymentPurpose_SpontaneousPayment_meth, spontaneous_payment_arr);
- }
- default: abort();
- }
-}
-static jclass LDKClosureReason_CounterpartyForceClosed_class = NULL;
-static jmethodID LDKClosureReason_CounterpartyForceClosed_meth = NULL;
-static jclass LDKClosureReason_HolderForceClosed_class = NULL;
-static jmethodID LDKClosureReason_HolderForceClosed_meth = NULL;
-static jclass LDKClosureReason_CooperativeClosure_class = NULL;
-static jmethodID LDKClosureReason_CooperativeClosure_meth = NULL;
-static jclass LDKClosureReason_CommitmentTxConfirmed_class = NULL;
-static jmethodID LDKClosureReason_CommitmentTxConfirmed_meth = NULL;
-static jclass LDKClosureReason_ProcessingError_class = NULL;
-static jmethodID LDKClosureReason_ProcessingError_meth = NULL;
-static jclass LDKClosureReason_DisconnectedPeer_class = NULL;
-static jmethodID LDKClosureReason_DisconnectedPeer_meth = NULL;
-static jclass LDKClosureReason_OutdatedChannelManager_class = NULL;
-static jmethodID LDKClosureReason_OutdatedChannelManager_meth = NULL;
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKClosureReason_init (JNIEnv *env, jclass clz) {
- LDKClosureReason_CounterpartyForceClosed_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$CounterpartyForceClosed;"));
- CHECK(LDKClosureReason_CounterpartyForceClosed_class != NULL);
- LDKClosureReason_CounterpartyForceClosed_meth = (*env)->GetMethodID(env, LDKClosureReason_CounterpartyForceClosed_class, "<init>", "(Ljava/lang/String;)V");
- CHECK(LDKClosureReason_CounterpartyForceClosed_meth != NULL);
- LDKClosureReason_HolderForceClosed_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$HolderForceClosed;"));
- CHECK(LDKClosureReason_HolderForceClosed_class != NULL);
- LDKClosureReason_HolderForceClosed_meth = (*env)->GetMethodID(env, LDKClosureReason_HolderForceClosed_class, "<init>", "()V");
- CHECK(LDKClosureReason_HolderForceClosed_meth != NULL);
- LDKClosureReason_CooperativeClosure_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$CooperativeClosure;"));
- CHECK(LDKClosureReason_CooperativeClosure_class != NULL);
- LDKClosureReason_CooperativeClosure_meth = (*env)->GetMethodID(env, LDKClosureReason_CooperativeClosure_class, "<init>", "()V");
- CHECK(LDKClosureReason_CooperativeClosure_meth != NULL);
- LDKClosureReason_CommitmentTxConfirmed_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$CommitmentTxConfirmed;"));
- CHECK(LDKClosureReason_CommitmentTxConfirmed_class != NULL);
- LDKClosureReason_CommitmentTxConfirmed_meth = (*env)->GetMethodID(env, LDKClosureReason_CommitmentTxConfirmed_class, "<init>", "()V");
- CHECK(LDKClosureReason_CommitmentTxConfirmed_meth != NULL);
- LDKClosureReason_ProcessingError_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$ProcessingError;"));
- CHECK(LDKClosureReason_ProcessingError_class != NULL);
- LDKClosureReason_ProcessingError_meth = (*env)->GetMethodID(env, LDKClosureReason_ProcessingError_class, "<init>", "(Ljava/lang/String;)V");
- CHECK(LDKClosureReason_ProcessingError_meth != NULL);
- LDKClosureReason_DisconnectedPeer_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$DisconnectedPeer;"));
- CHECK(LDKClosureReason_DisconnectedPeer_class != NULL);
- LDKClosureReason_DisconnectedPeer_meth = (*env)->GetMethodID(env, LDKClosureReason_DisconnectedPeer_class, "<init>", "()V");
- CHECK(LDKClosureReason_DisconnectedPeer_meth != NULL);
- LDKClosureReason_OutdatedChannelManager_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKClosureReason$OutdatedChannelManager;"));
- CHECK(LDKClosureReason_OutdatedChannelManager_class != NULL);
- LDKClosureReason_OutdatedChannelManager_meth = (*env)->GetMethodID(env, LDKClosureReason_OutdatedChannelManager_class, "<init>", "()V");
- CHECK(LDKClosureReason_OutdatedChannelManager_meth != NULL);
-}
-JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKClosureReason_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
- LDKClosureReason *obj = (LDKClosureReason*)(ptr & ~1);
- switch(obj->tag) {
- case LDKClosureReason_CounterpartyForceClosed: {
- LDKStr peer_msg_str = obj->counterparty_force_closed.peer_msg;
- jstring peer_msg_conv = str_ref_to_java(env, peer_msg_str.chars, peer_msg_str.len);
- return (*env)->NewObject(env, LDKClosureReason_CounterpartyForceClosed_class, LDKClosureReason_CounterpartyForceClosed_meth, peer_msg_conv);
- }
- case LDKClosureReason_HolderForceClosed: {
- return (*env)->NewObject(env, LDKClosureReason_HolderForceClosed_class, LDKClosureReason_HolderForceClosed_meth);
- }
- case LDKClosureReason_CooperativeClosure: {
- return (*env)->NewObject(env, LDKClosureReason_CooperativeClosure_class, LDKClosureReason_CooperativeClosure_meth);
- }
- case LDKClosureReason_CommitmentTxConfirmed: {
- return (*env)->NewObject(env, LDKClosureReason_CommitmentTxConfirmed_class, LDKClosureReason_CommitmentTxConfirmed_meth);
- }
- case LDKClosureReason_ProcessingError: {
- LDKStr err_str = obj->processing_error.err;
- jstring err_conv = str_ref_to_java(env, err_str.chars, err_str.len);
- return (*env)->NewObject(env, LDKClosureReason_ProcessingError_class, LDKClosureReason_ProcessingError_meth, err_conv);
- }
- case LDKClosureReason_DisconnectedPeer: {
- return (*env)->NewObject(env, LDKClosureReason_DisconnectedPeer_class, LDKClosureReason_DisconnectedPeer_meth);
- }
- case LDKClosureReason_OutdatedChannelManager: {
- return (*env)->NewObject(env, LDKClosureReason_OutdatedChannelManager_class, LDKClosureReason_OutdatedChannelManager_meth);
- }
- default: abort();
- }
-}
-static jclass LDKEvent_FundingGenerationReady_class = NULL;
-static jmethodID LDKEvent_FundingGenerationReady_meth = NULL;
-static jclass LDKEvent_PaymentReceived_class = NULL;
-static jmethodID LDKEvent_PaymentReceived_meth = NULL;
-static jclass LDKEvent_PaymentSent_class = NULL;
-static jmethodID LDKEvent_PaymentSent_meth = NULL;
-static jclass LDKEvent_PaymentPathFailed_class = NULL;
-static jmethodID LDKEvent_PaymentPathFailed_meth = NULL;
-static jclass LDKEvent_PendingHTLCsForwardable_class = NULL;
-static jmethodID LDKEvent_PendingHTLCsForwardable_meth = NULL;
-static jclass LDKEvent_SpendableOutputs_class = NULL;
-static jmethodID LDKEvent_SpendableOutputs_meth = NULL;
-static jclass LDKEvent_PaymentForwarded_class = NULL;
-static jmethodID LDKEvent_PaymentForwarded_meth = NULL;
-static jclass LDKEvent_ChannelClosed_class = NULL;
-static jmethodID LDKEvent_ChannelClosed_meth = NULL;
-static jclass LDKEvent_DiscardFunding_class = NULL;
-static jmethodID LDKEvent_DiscardFunding_meth = NULL;
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_00024LDKEvent_init (JNIEnv *env, jclass clz) {
- LDKEvent_FundingGenerationReady_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$FundingGenerationReady;"));
- CHECK(LDKEvent_FundingGenerationReady_class != NULL);
- LDKEvent_FundingGenerationReady_meth = (*env)->GetMethodID(env, LDKEvent_FundingGenerationReady_class, "<init>", "([BJ[BJ)V");
- CHECK(LDKEvent_FundingGenerationReady_meth != NULL);
- LDKEvent_PaymentReceived_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PaymentReceived;"));
- CHECK(LDKEvent_PaymentReceived_class != NULL);
- LDKEvent_PaymentReceived_meth = (*env)->GetMethodID(env, LDKEvent_PaymentReceived_class, "<init>", "([BJJ)V");
- CHECK(LDKEvent_PaymentReceived_meth != NULL);
- LDKEvent_PaymentSent_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PaymentSent;"));
- CHECK(LDKEvent_PaymentSent_class != NULL);
- LDKEvent_PaymentSent_meth = (*env)->GetMethodID(env, LDKEvent_PaymentSent_class, "<init>", "([B[B[BJ)V");
- CHECK(LDKEvent_PaymentSent_meth != NULL);
- LDKEvent_PaymentPathFailed_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PaymentPathFailed;"));
- CHECK(LDKEvent_PaymentPathFailed_class != NULL);
- LDKEvent_PaymentPathFailed_meth = (*env)->GetMethodID(env, LDKEvent_PaymentPathFailed_class, "<init>", "([B[BZJZ[JJJ)V");
- CHECK(LDKEvent_PaymentPathFailed_meth != NULL);
- LDKEvent_PendingHTLCsForwardable_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PendingHTLCsForwardable;"));
- CHECK(LDKEvent_PendingHTLCsForwardable_class != NULL);
- LDKEvent_PendingHTLCsForwardable_meth = (*env)->GetMethodID(env, LDKEvent_PendingHTLCsForwardable_class, "<init>", "(J)V");
- CHECK(LDKEvent_PendingHTLCsForwardable_meth != NULL);
- LDKEvent_SpendableOutputs_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$SpendableOutputs;"));
- CHECK(LDKEvent_SpendableOutputs_class != NULL);
- LDKEvent_SpendableOutputs_meth = (*env)->GetMethodID(env, LDKEvent_SpendableOutputs_class, "<init>", "([J)V");
- CHECK(LDKEvent_SpendableOutputs_meth != NULL);
- LDKEvent_PaymentForwarded_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$PaymentForwarded;"));
- CHECK(LDKEvent_PaymentForwarded_class != NULL);
- LDKEvent_PaymentForwarded_meth = (*env)->GetMethodID(env, LDKEvent_PaymentForwarded_class, "<init>", "(JZ)V");
- CHECK(LDKEvent_PaymentForwarded_meth != NULL);
- LDKEvent_ChannelClosed_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$ChannelClosed;"));
- CHECK(LDKEvent_ChannelClosed_class != NULL);
- LDKEvent_ChannelClosed_meth = (*env)->GetMethodID(env, LDKEvent_ChannelClosed_class, "<init>", "([BJJ)V");
- CHECK(LDKEvent_ChannelClosed_meth != NULL);
- LDKEvent_DiscardFunding_class =
- (*env)->NewGlobalRef(env, (*env)->FindClass(env, "Lorg/ldk/impl/bindings$LDKEvent$DiscardFunding;"));
- CHECK(LDKEvent_DiscardFunding_class != NULL);
- LDKEvent_DiscardFunding_meth = (*env)->GetMethodID(env, LDKEvent_DiscardFunding_class, "<init>", "([B[B)V");
- CHECK(LDKEvent_DiscardFunding_meth != NULL);
-}
-JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKEvent_1ref_1from_1ptr(JNIEnv *env, jclass clz, int64_t ptr) {
- LDKEvent *obj = (LDKEvent*)(ptr & ~1);
- switch(obj->tag) {
- case LDKEvent_FundingGenerationReady: {
- int8_tArray temporary_channel_id_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, temporary_channel_id_arr, 0, 32, obj->funding_generation_ready.temporary_channel_id.data);
- LDKCVec_u8Z output_script_var = obj->funding_generation_ready.output_script;
- int8_tArray output_script_arr = (*env)->NewByteArray(env, output_script_var.datalen);
- (*env)->SetByteArrayRegion(env, output_script_arr, 0, output_script_var.datalen, output_script_var.data);
- return (*env)->NewObject(env, LDKEvent_FundingGenerationReady_class, LDKEvent_FundingGenerationReady_meth, temporary_channel_id_arr, obj->funding_generation_ready.channel_value_satoshis, output_script_arr, obj->funding_generation_ready.user_channel_id);
- }
- case LDKEvent_PaymentReceived: {
- int8_tArray payment_hash_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, payment_hash_arr, 0, 32, obj->payment_received.payment_hash.data);
- uint64_t purpose_ref = ((uint64_t)&obj->payment_received.purpose) | 1;
- return (*env)->NewObject(env, LDKEvent_PaymentReceived_class, LDKEvent_PaymentReceived_meth, payment_hash_arr, obj->payment_received.amt, purpose_ref);
- }
- case LDKEvent_PaymentSent: {
- int8_tArray payment_id_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, payment_id_arr, 0, 32, obj->payment_sent.payment_id.data);
- int8_tArray payment_preimage_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, payment_preimage_arr, 0, 32, obj->payment_sent.payment_preimage.data);
- int8_tArray payment_hash_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, payment_hash_arr, 0, 32, obj->payment_sent.payment_hash.data);
- uint64_t fee_paid_msat_ref = ((uint64_t)&obj->payment_sent.fee_paid_msat) | 1;
- return (*env)->NewObject(env, LDKEvent_PaymentSent_class, LDKEvent_PaymentSent_meth, payment_id_arr, payment_preimage_arr, payment_hash_arr, fee_paid_msat_ref);
- }
- case LDKEvent_PaymentPathFailed: {
- int8_tArray payment_id_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, payment_id_arr, 0, 32, obj->payment_path_failed.payment_id.data);
- int8_tArray payment_hash_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, payment_hash_arr, 0, 32, obj->payment_path_failed.payment_hash.data);
- uint64_t network_update_ref = ((uint64_t)&obj->payment_path_failed.network_update) | 1;
- LDKCVec_RouteHopZ path_var = obj->payment_path_failed.path;
- int64_tArray path_arr = NULL;
- path_arr = (*env)->NewLongArray(env, path_var.datalen);
- int64_t *path_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, path_arr, NULL);
- for (size_t k = 0; k < path_var.datalen; k++) {
- LDKRouteHop path_conv_10_var = path_var.data[k];
- uint64_t path_conv_10_ref = 0;
- CHECK((((uint64_t)path_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
- CHECK((((uint64_t)&path_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
- path_conv_10_ref = (uint64_t)path_conv_10_var.inner & ~1;
- path_arr_ptr[k] = path_conv_10_ref;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, path_arr, path_arr_ptr, 0);
- uint64_t short_channel_id_ref = ((uint64_t)&obj->payment_path_failed.short_channel_id) | 1;
- LDKRouteParameters retry_var = obj->payment_path_failed.retry;
- uint64_t retry_ref = 0;
- if ((uint64_t)retry_var.inner > 4096) {
- CHECK((((uint64_t)retry_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
- CHECK((((uint64_t)&retry_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
- retry_ref = (uint64_t)retry_var.inner & ~1;
- }
- return (*env)->NewObject(env, LDKEvent_PaymentPathFailed_class, LDKEvent_PaymentPathFailed_meth, payment_id_arr, payment_hash_arr, obj->payment_path_failed.rejected_by_dest, network_update_ref, obj->payment_path_failed.all_paths_failed, path_arr, short_channel_id_ref, retry_ref);
- }
- case LDKEvent_PendingHTLCsForwardable: {
- return (*env)->NewObject(env, LDKEvent_PendingHTLCsForwardable_class, LDKEvent_PendingHTLCsForwardable_meth, obj->pending_htl_cs_forwardable.time_forwardable);
- }
- case LDKEvent_SpendableOutputs: {
- LDKCVec_SpendableOutputDescriptorZ outputs_var = obj->spendable_outputs.outputs;
- int64_tArray outputs_arr = NULL;
- outputs_arr = (*env)->NewLongArray(env, outputs_var.datalen);
- int64_t *outputs_arr_ptr = (*env)->GetPrimitiveArrayCritical(env, outputs_arr, NULL);
- for (size_t b = 0; b < outputs_var.datalen; b++) {
- uint64_t outputs_conv_27_ref = ((uint64_t)&outputs_var.data[b]) | 1;
- outputs_arr_ptr[b] = outputs_conv_27_ref;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, outputs_arr, outputs_arr_ptr, 0);
- return (*env)->NewObject(env, LDKEvent_SpendableOutputs_class, LDKEvent_SpendableOutputs_meth, outputs_arr);
- }
- case LDKEvent_PaymentForwarded: {
- uint64_t fee_earned_msat_ref = ((uint64_t)&obj->payment_forwarded.fee_earned_msat) | 1;
- return (*env)->NewObject(env, LDKEvent_PaymentForwarded_class, LDKEvent_PaymentForwarded_meth, fee_earned_msat_ref, obj->payment_forwarded.claim_from_onchain_tx);
- }
- case LDKEvent_ChannelClosed: {
- int8_tArray channel_id_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, channel_id_arr, 0, 32, obj->channel_closed.channel_id.data);
- uint64_t reason_ref = ((uint64_t)&obj->channel_closed.reason) | 1;
- return (*env)->NewObject(env, LDKEvent_ChannelClosed_class, LDKEvent_ChannelClosed_meth, channel_id_arr, obj->channel_closed.user_channel_id, reason_ref);
- }
- case LDKEvent_DiscardFunding: {
- int8_tArray channel_id_arr = (*env)->NewByteArray(env, 32);
- (*env)->SetByteArrayRegion(env, channel_id_arr, 0, 32, obj->discard_funding.channel_id.data);
- LDKTransaction transaction_var = obj->discard_funding.transaction;
- int8_tArray transaction_arr = (*env)->NewByteArray(env, transaction_var.datalen);
- (*env)->SetByteArrayRegion(env, transaction_arr, 0, transaction_var.datalen, transaction_var.data);
- return (*env)->NewObject(env, LDKEvent_DiscardFunding_class, LDKEvent_DiscardFunding_meth, channel_id_arr, transaction_arr);
- }
- default: abort();
- }
-}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1EventZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_EventZ *ret = MALLOC(sizeof(LDKCVec_EventZ), "LDKCVec_EventZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKEvent) * ret->datalen, "LDKCVec_EventZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKEvent arr_elem_conv = *(LDKEvent*)(arr_elem_ptr);
- arr_elem_conv = Event_clone((LDKEvent*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_EventZ CVec_EventZ_clone(const LDKCVec_EventZ *orig) {
LDKCVec_EventZ ret = { .data = MALLOC(sizeof(LDKEvent) * orig->datalen, "LDKCVec_EventZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
return (uint64_t)ret_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1u32TxOutZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_C2Tuple_u32TxOutZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_u32TxOutZZ), "LDKCVec_C2Tuple_u32TxOutZZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ) * ret->datalen, "LDKCVec_C2Tuple_u32TxOutZZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_u32TxOutZ arr_elem_conv = *(LDKC2Tuple_u32TxOutZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_u32TxOutZ_clone((LDKC2Tuple_u32TxOutZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_u32TxOutZZ CVec_C2Tuple_u32TxOutZZ_clone(const LDKCVec_C2Tuple_u32TxOutZZ *orig) {
LDKCVec_C2Tuple_u32TxOutZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ) * orig->datalen, "LDKCVec_C2Tuple_u32TxOutZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
return ret_arr;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ) * ret->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ arr_elem_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone((LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_clone(const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ *orig) {
LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ) * orig->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
default: abort();
}
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1BalanceZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_BalanceZ *ret = MALLOC(sizeof(LDKCVec_BalanceZ), "LDKCVec_BalanceZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKBalance) * ret->datalen, "LDKCVec_BalanceZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKBalance arr_elem_conv = *(LDKBalance*)(arr_elem_ptr);
- arr_elem_conv = Balance_clone((LDKBalance*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_BalanceZ CVec_BalanceZ_clone(const LDKCVec_BalanceZ *orig) {
LDKCVec_BalanceZ ret = { .data = MALLOC(sizeof(LDKBalance) * orig->datalen, "LDKCVec_BalanceZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NoneLightningErrorZ*)arg)->result_ok;
-}
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NoneLightningErrorZ *val = (LDKCResult_NoneLightningErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
return (uint64_t)ret_ret;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1PublicKeyTypeZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_C2Tuple_PublicKeyTypeZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_PublicKeyTypeZZ), "LDKCVec_C2Tuple_PublicKeyTypeZZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ) * ret->datalen, "LDKCVec_C2Tuple_PublicKeyTypeZZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_PublicKeyTypeZ arr_elem_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_PublicKeyTypeZ_clone((LDKC2Tuple_PublicKeyTypeZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_PublicKeyTypeZZ CVec_C2Tuple_PublicKeyTypeZZ_clone(const LDKCVec_C2Tuple_PublicKeyTypeZZ *orig) {
LDKCVec_C2Tuple_PublicKeyTypeZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ) * orig->datalen, "LDKCVec_C2Tuple_PublicKeyTypeZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_boolLightningErrorZ*)arg)->result_ok;
-}
JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_boolLightningErrorZ *val = (LDKCResult_boolLightningErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret = MALLOC(sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) * ret->datalen, "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ arr_elem_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(arr_elem_ptr);
- arr_elem_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone((LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *orig) {
LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret = { .data = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) * orig->datalen, "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1NodeAnnouncementZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_NodeAnnouncementZ *ret = MALLOC(sizeof(LDKCVec_NodeAnnouncementZ), "LDKCVec_NodeAnnouncementZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKNodeAnnouncement) * ret->datalen, "LDKCVec_NodeAnnouncementZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKNodeAnnouncement arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = NodeAnnouncement_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_NodeAnnouncementZ CVec_NodeAnnouncementZ_clone(const LDKCVec_NodeAnnouncementZ *orig) {
LDKCVec_NodeAnnouncementZ ret = { .data = MALLOC(sizeof(LDKNodeAnnouncement) * orig->datalen, "LDKCVec_NodeAnnouncementZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_CVec_u8ZPeerHandleErrorZ*)arg)->result_ok;
-}
JNIEXPORT int8_tArray JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_CVec_u8ZPeerHandleErrorZ *val = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NonePeerHandleErrorZ*)arg)->result_ok;
-}
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NonePeerHandleErrorZ *val = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_boolPeerHandleErrorZ*)arg)->result_ok;
-}
JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_boolPeerHandleErrorZ *val = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeIdDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NodeIdDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeIdDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NodeIdDecodeErrorZ *val = (LDKCResult_NodeIdDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
+ err_ref = (uint64_t)err_var.inner & ~1;
+ return err_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1NetworkUpdateZDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ *val = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(arg & ~1);
+ CHECK(val->result_ok);
+ uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
+ return res_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1NetworkUpdateZDecodeErrorZ_1get_1err(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ *val = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(arg & ~1);
+ CHECK(!val->result_ok);
+ LDKDecodeError err_var = (*val->contents.err);
+ uint64_t err_ref = 0;
+ CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_TxOutAccessErrorZ ret_conv = *(LDKCResult_TxOutAccessErrorZ*)(ret_ptr);
- ret_conv = CResult_TxOutAccessErrorZ_clone((LDKCResult_TxOutAccessErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
default: abort();
}
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DirectionalChannelInfoDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_DirectionalChannelInfoDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DirectionalChannelInfoDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_DirectionalChannelInfoDecodeErrorZ *val = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelInfoDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ChannelInfoDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelInfoDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ChannelInfoDecodeErrorZ *val = (LDKCResult_ChannelInfoDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RoutingFeesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_RoutingFeesDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RoutingFeesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_RoutingFeesDecodeErrorZ *val = (LDKCResult_RoutingFeesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementInfoDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementInfoDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NodeAnnouncementInfoDecodeErrorZ *val = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1u64Z_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_u64Z *ret = MALLOC(sizeof(LDKCVec_u64Z), "LDKCVec_u64Z");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(uint64_t) * ret->datalen, "LDKCVec_u64Z Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- ret->data[i] = java_elems[i];
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_u64Z CVec_u64Z_clone(const LDKCVec_u64Z *orig) {
LDKCVec_u64Z ret = { .data = MALLOC(sizeof(int64_t) * orig->datalen, "LDKCVec_u64Z clone bytes"), .datalen = orig->datalen };
memcpy(ret.data, orig->data, sizeof(int64_t) * ret.datalen);
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeInfoDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NodeInfoDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeInfoDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NodeInfoDecodeErrorZ *val = (LDKCResult_NodeInfoDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetworkGraphDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NetworkGraphDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetworkGraphDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NetworkGraphDecodeErrorZ *val = (LDKCResult_NetworkGraphDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
default: abort();
}
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetAddressDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NetAddressDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetAddressDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NetAddressDecodeErrorZ *val = (LDKCResult_NetAddressDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1UpdateAddHTLCZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_UpdateAddHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateAddHTLCZ), "LDKCVec_UpdateAddHTLCZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKUpdateAddHTLC) * ret->datalen, "LDKCVec_UpdateAddHTLCZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKUpdateAddHTLC arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = UpdateAddHTLC_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_UpdateAddHTLCZ CVec_UpdateAddHTLCZ_clone(const LDKCVec_UpdateAddHTLCZ *orig) {
LDKCVec_UpdateAddHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateAddHTLC) * orig->datalen, "LDKCVec_UpdateAddHTLCZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1UpdateFulfillHTLCZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_UpdateFulfillHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateFulfillHTLCZ), "LDKCVec_UpdateFulfillHTLCZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKUpdateFulfillHTLC) * ret->datalen, "LDKCVec_UpdateFulfillHTLCZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKUpdateFulfillHTLC arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = UpdateFulfillHTLC_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_UpdateFulfillHTLCZ CVec_UpdateFulfillHTLCZ_clone(const LDKCVec_UpdateFulfillHTLCZ *orig) {
LDKCVec_UpdateFulfillHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFulfillHTLC) * orig->datalen, "LDKCVec_UpdateFulfillHTLCZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1UpdateFailHTLCZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_UpdateFailHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateFailHTLCZ), "LDKCVec_UpdateFailHTLCZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKUpdateFailHTLC) * ret->datalen, "LDKCVec_UpdateFailHTLCZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKUpdateFailHTLC arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = UpdateFailHTLC_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_UpdateFailHTLCZ CVec_UpdateFailHTLCZ_clone(const LDKCVec_UpdateFailHTLCZ *orig) {
LDKCVec_UpdateFailHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailHTLC) * orig->datalen, "LDKCVec_UpdateFailHTLCZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1UpdateFailMalformedHTLCZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_UpdateFailMalformedHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateFailMalformedHTLCZ), "LDKCVec_UpdateFailMalformedHTLCZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKUpdateFailMalformedHTLC) * ret->datalen, "LDKCVec_UpdateFailMalformedHTLCZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKUpdateFailMalformedHTLC arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = UpdateFailMalformedHTLC_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_UpdateFailMalformedHTLCZ CVec_UpdateFailMalformedHTLCZ_clone(const LDKCVec_UpdateFailMalformedHTLCZ *orig) {
LDKCVec_UpdateFailMalformedHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailMalformedHTLC) * orig->datalen, "LDKCVec_UpdateFailMalformedHTLCZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AcceptChannelDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_AcceptChannelDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AcceptChannelDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_AcceptChannelDecodeErrorZ *val = (LDKCResult_AcceptChannelDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AnnouncementSignaturesDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_AnnouncementSignaturesDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AnnouncementSignaturesDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_AnnouncementSignaturesDecodeErrorZ *val = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelReestablishDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ChannelReestablishDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelReestablishDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ChannelReestablishDecodeErrorZ *val = (LDKCResult_ChannelReestablishDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ClosingSignedDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ClosingSignedDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ClosingSignedDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ClosingSignedDecodeErrorZ *val = (LDKCResult_ClosingSignedDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ClosingSignedFeeRangeDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ClosingSignedFeeRangeDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *val = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentSignedDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_CommitmentSignedDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentSignedDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_CommitmentSignedDecodeErrorZ *val = (LDKCResult_CommitmentSignedDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingCreatedDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_FundingCreatedDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingCreatedDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_FundingCreatedDecodeErrorZ *val = (LDKCResult_FundingCreatedDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingSignedDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_FundingSignedDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingSignedDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_FundingSignedDecodeErrorZ *val = (LDKCResult_FundingSignedDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingLockedDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_FundingLockedDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingLockedDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_FundingLockedDecodeErrorZ *val = (LDKCResult_FundingLockedDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_InitDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_InitDecodeErrorZ *val = (LDKCResult_InitDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OpenChannelDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_OpenChannelDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OpenChannelDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_OpenChannelDecodeErrorZ *val = (LDKCResult_OpenChannelDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RevokeAndACKDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_RevokeAndACKDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RevokeAndACKDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_RevokeAndACKDecodeErrorZ *val = (LDKCResult_RevokeAndACKDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ShutdownDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ShutdownDecodeErrorZ *val = (LDKCResult_ShutdownDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailHTLCDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_UpdateFailHTLCDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailHTLCDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_UpdateFailHTLCDecodeErrorZ *val = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailMalformedHTLCDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailMalformedHTLCDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *val = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFeeDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_UpdateFeeDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFeeDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_UpdateFeeDecodeErrorZ *val = (LDKCResult_UpdateFeeDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFulfillHTLCDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFulfillHTLCDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_UpdateFulfillHTLCDecodeErrorZ *val = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateAddHTLCDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_UpdateAddHTLCDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateAddHTLCDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_UpdateAddHTLCDecodeErrorZ *val = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PingDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_PingDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PingDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_PingDecodeErrorZ *val = (LDKCResult_PingDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PongDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_PongDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PongDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_PongDecodeErrorZ *val = (LDKCResult_PongDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelAnnouncementDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelAnnouncementDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *val = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelAnnouncementDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ChannelAnnouncementDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelAnnouncementDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ChannelAnnouncementDecodeErrorZ *val = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelUpdateDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelUpdateDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_UnsignedChannelUpdateDecodeErrorZ *val = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelUpdateDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ChannelUpdateDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelUpdateDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ChannelUpdateDecodeErrorZ *val = (LDKCResult_ChannelUpdateDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ErrorMessageDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ErrorMessageDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ErrorMessageDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ErrorMessageDecodeErrorZ *val = (LDKCResult_ErrorMessageDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedNodeAnnouncementDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedNodeAnnouncementDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *val = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_NodeAnnouncementDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_NodeAnnouncementDecodeErrorZ *val = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryShortChannelIdsDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_QueryShortChannelIdsDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryShortChannelIdsDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_QueryShortChannelIdsDecodeErrorZ *val = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyShortChannelIdsEndDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyShortChannelIdsEndDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *val = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryChannelRangeDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_QueryChannelRangeDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryChannelRangeDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_QueryChannelRangeDecodeErrorZ *val = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyChannelRangeDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_ReplyChannelRangeDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyChannelRangeDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_ReplyChannelRangeDecodeErrorZ *val = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1GossipTimestampFilterDecodeErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_GossipTimestampFilterDecodeErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1GossipTimestampFilterDecodeErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_GossipTimestampFilterDecodeErrorZ *val = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
default: abort();
}
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceSignOrCreationErrorZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_InvoiceSignOrCreationErrorZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceSignOrCreationErrorZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_InvoiceSignOrCreationErrorZ *val = (LDKCResult_InvoiceSignOrCreationErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t output_ref = 0;
CHECK((((uint64_t)output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(output_var);
output_ref = (uint64_t)output_var.inner;
if (output_var.is_owned) {
output_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCOption_C2Tuple_usizeTransactionZZ ret_conv = *(LDKCOption_C2Tuple_usizeTransactionZZ*)(ret_ptr);
- ret_conv = COption_C2Tuple_usizeTransactionZZ_clone((LDKCOption_C2Tuple_usizeTransactionZZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
LDKWatchedOutput output_conv;
output_conv.inner = (void*)(output & (~1));
output_conv.is_owned = (output & 1) || (output == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(output_conv);
output_conv = WatchedOutput_clone(&output_conv);
LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
*ret_copy = (this_arg_conv->register_output)(this_arg_conv->this_arg, output_conv);
default: abort();
}
}
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1LockedChannelMonitorNoneZ_1result_1ok(JNIEnv *env, jclass clz, int64_t arg) {
- return ((LDKCResult_LockedChannelMonitorNoneZ*)arg)->result_ok;
-}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCResult_1LockedChannelMonitorNoneZ_1get_1ok(JNIEnv *env, jclass clz, int64_t arg) {
LDKCResult_LockedChannelMonitorNoneZ *val = (LDKCResult_LockedChannelMonitorNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
CHECK(!val->result_ok);
return *val->contents.err;
}
-JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LDKCVec_1OutPointZ_1new(JNIEnv *env, jclass clz, int64_tArray elems) {
- LDKCVec_OutPointZ *ret = MALLOC(sizeof(LDKCVec_OutPointZ), "LDKCVec_OutPointZ");
- ret->datalen = (*env)->GetArrayLength(env, elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKOutPoint) * ret->datalen, "LDKCVec_OutPointZ Data");
- int64_t *java_elems = (*env)->GetPrimitiveArrayCritical(env, elems, NULL);
- for (size_t i = 0; i < ret->datalen; i++) {
- int64_t arr_elem = java_elems[i];
- LDKOutPoint arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = OutPoint_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- (*env)->ReleasePrimitiveArrayCritical(env, elems, java_elems, 0);
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_OutPointZ CVec_OutPointZ_clone(const LDKCVec_OutPointZ *orig) {
LDKCVec_OutPointZ ret = { .data = MALLOC(sizeof(LDKOutPoint) * orig->datalen, "LDKCVec_OutPointZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
void* ret_conv_18_ptr = (void*)(((uint64_t)ret_conv_18) & ~1);
CHECK_ACCESS(ret_conv_18_ptr);
LDKMessageSendEvent ret_conv_18_conv = *(LDKMessageSendEvent*)(ret_conv_18_ptr);
- ret_conv_18_conv = MessageSendEvent_clone((LDKMessageSendEvent*)(((uint64_t)ret_conv_18) & ~1));
+ FREE((void*)ret_conv_18);
ret_constr.data[s] = ret_conv_18_conv;
}
(*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
uint64_t channel_id_ref = 0;
CHECK((((uint64_t)channel_id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&channel_id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_var);
channel_id_ref = (uint64_t)channel_id_var.inner;
if (channel_id_var.is_owned) {
channel_id_ref |= 1;
data_var = ChannelMonitor_clone(data);
CHECK((((uint64_t)data_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&data_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(data_var);
data_ref = (uint64_t)data_var.inner;
if (data_var.is_owned) {
data_ref |= 1;
uint64_t update_id_ref = 0;
CHECK((((uint64_t)update_id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_var);
update_id_ref = (uint64_t)update_id_var.inner;
if (update_id_var.is_owned) {
update_id_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(ret_ptr);
- ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
uint64_t channel_id_ref = 0;
CHECK((((uint64_t)channel_id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&channel_id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_var);
channel_id_ref = (uint64_t)channel_id_var.inner;
if (channel_id_var.is_owned) {
channel_id_ref |= 1;
update_var = ChannelMonitorUpdate_clone(update);
CHECK((((uint64_t)update_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_var);
update_ref = (uint64_t)update_var.inner;
if (update_var.is_owned) {
update_ref |= 1;
data_var = ChannelMonitor_clone(data);
CHECK((((uint64_t)data_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&data_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(data_var);
data_ref = (uint64_t)data_var.inner;
if (data_var.is_owned) {
data_ref |= 1;
uint64_t update_id_ref = 0;
CHECK((((uint64_t)update_id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_var);
update_id_ref = (uint64_t)update_id_var.inner;
if (update_id_var.is_owned) {
update_id_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(ret_ptr);
- ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
LDKOutPoint channel_id_conv;
channel_id_conv.inner = (void*)(channel_id & (~1));
channel_id_conv.is_owned = (channel_id & 1) || (channel_id == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_conv);
channel_id_conv = OutPoint_clone(&channel_id_conv);
LDKChannelMonitor data_conv;
data_conv.inner = (void*)(data & (~1));
data_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(data_conv);
LDKMonitorUpdateId update_id_conv;
update_id_conv.inner = (void*)(update_id & (~1));
update_id_conv.is_owned = (update_id & 1) || (update_id == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_conv);
update_id_conv = MonitorUpdateId_clone(&update_id_conv);
LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
*ret_conv = (this_arg_conv->persist_new_channel)(this_arg_conv->this_arg, channel_id_conv, &data_conv, update_id_conv);
LDKOutPoint channel_id_conv;
channel_id_conv.inner = (void*)(channel_id & (~1));
channel_id_conv.is_owned = (channel_id & 1) || (channel_id == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_conv);
channel_id_conv = OutPoint_clone(&channel_id_conv);
LDKChannelMonitorUpdate update_conv;
update_conv.inner = (void*)(update & (~1));
update_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_conv);
LDKChannelMonitor data_conv;
data_conv.inner = (void*)(data & (~1));
data_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(data_conv);
LDKMonitorUpdateId update_id_conv;
update_id_conv.inner = (void*)(update_id & (~1));
update_id_conv.is_owned = (update_id & 1) || (update_id == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_conv);
update_id_conv = MonitorUpdateId_clone(&update_id_conv);
LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
*ret_conv = (this_arg_conv->update_persisted_channel)(this_arg_conv->this_arg, channel_id_conv, &update_conv, &data_conv, update_id_conv);
uint64_t their_features_ref = 0;
CHECK((((uint64_t)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_var);
their_features_ref = (uint64_t)their_features_var.inner;
if (their_features_var.is_owned) {
their_features_ref |= 1;
msg_var = OpenChannel_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
uint64_t their_features_ref = 0;
CHECK((((uint64_t)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_var);
their_features_ref = (uint64_t)their_features_var.inner;
if (their_features_var.is_owned) {
their_features_ref |= 1;
msg_var = AcceptChannel_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = FundingCreated_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = FundingSigned_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = FundingLocked_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
their_features_var = InitFeatures_clone(their_features);
CHECK((((uint64_t)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_var);
their_features_ref = (uint64_t)their_features_var.inner;
if (their_features_var.is_owned) {
their_features_ref |= 1;
msg_var = Shutdown_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = ClosingSigned_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = UpdateAddHTLC_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = UpdateFulfillHTLC_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = UpdateFailHTLC_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = UpdateFailMalformedHTLC_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = CommitmentSigned_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = RevokeAndACK_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = UpdateFee_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = AnnouncementSignatures_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = Init_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = ChannelReestablish_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = ChannelUpdate_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = ErrorMessage_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
LDKInitFeatures their_features_conv;
their_features_conv.inner = (void*)(their_features & (~1));
their_features_conv.is_owned = (their_features & 1) || (their_features == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_conv);
their_features_conv = InitFeatures_clone(&their_features_conv);
LDKOpenChannel msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_open_channel)(this_arg_conv->this_arg, their_node_id_ref, their_features_conv, &msg_conv);
}
LDKInitFeatures their_features_conv;
their_features_conv.inner = (void*)(their_features & (~1));
their_features_conv.is_owned = (their_features & 1) || (their_features == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_conv);
their_features_conv = InitFeatures_clone(&their_features_conv);
LDKAcceptChannel msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_accept_channel)(this_arg_conv->this_arg, their_node_id_ref, their_features_conv, &msg_conv);
}
LDKFundingCreated msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_funding_created)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKFundingSigned msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_funding_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKFundingLocked msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_funding_locked)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKInitFeatures their_features_conv;
their_features_conv.inner = (void*)(their_features & (~1));
their_features_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_conv);
LDKShutdown msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_shutdown)(this_arg_conv->this_arg, their_node_id_ref, &their_features_conv, &msg_conv);
}
LDKClosingSigned msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_closing_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKUpdateAddHTLC msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_update_add_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKUpdateFulfillHTLC msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_update_fulfill_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKUpdateFailHTLC msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_update_fail_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKUpdateFailMalformedHTLC msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_update_fail_malformed_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKCommitmentSigned msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_commitment_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKRevokeAndACK msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_revoke_and_ack)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKUpdateFee msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_update_fee)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKAnnouncementSignatures msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_announcement_signatures)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKInit msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->peer_connected)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKChannelReestablish msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_channel_reestablish)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKErrorMessage msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_error)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
msg_var = NodeAnnouncement_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
msg_var = ChannelAnnouncement_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
msg_var = ChannelUpdate_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
void* ret_conv_59_ptr = (void*)(((uint64_t)ret_conv_59) & ~1);
CHECK_ACCESS(ret_conv_59_ptr);
LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ ret_conv_59_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ret_conv_59_ptr);
- ret_conv_59_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone((LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)ret_conv_59) & ~1));
+ FREE((void*)ret_conv_59);
ret_constr.data[h] = ret_conv_59_conv;
}
(*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
LDKNodeAnnouncement ret_conv_18_conv;
ret_conv_18_conv.inner = (void*)(ret_conv_18 & (~1));
ret_conv_18_conv.is_owned = (ret_conv_18 & 1) || (ret_conv_18 == 0);
- ret_conv_18_conv = NodeAnnouncement_clone(&ret_conv_18_conv);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_18_conv);
ret_constr.data[s] = ret_conv_18_conv;
}
(*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
init_var = Init_clone(init);
CHECK((((uint64_t)init_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&init_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(init_var);
init_ref = (uint64_t)init_var.inner;
if (init_var.is_owned) {
init_ref |= 1;
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
LDKNodeAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
*ret_conv = (this_arg_conv->handle_node_announcement)(this_arg_conv->this_arg, &msg_conv);
return (uint64_t)ret_conv;
LDKChannelAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
*ret_conv = (this_arg_conv->handle_channel_announcement)(this_arg_conv->this_arg, &msg_conv);
return (uint64_t)ret_conv;
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
*ret_conv = (this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, &msg_conv);
return (uint64_t)ret_conv;
uint64_t ret_conv_18_ref = 0;
CHECK((((uint64_t)ret_conv_18_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_18_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_18_var);
ret_conv_18_ref = (uint64_t)ret_conv_18_var.inner;
if (ret_conv_18_var.is_owned) {
ret_conv_18_ref |= 1;
LDKInit init_conv;
init_conv.inner = (void*)(init & (~1));
init_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(init_conv);
(this_arg_conv->sync_routing_table)(this_arg_conv->this_arg, their_node_id_ref, &init_conv);
}
LDKReplyChannelRange msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ReplyChannelRange_clone(&msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = (this_arg_conv->handle_reply_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
LDKReplyShortChannelIdsEnd msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ReplyShortChannelIdsEnd_clone(&msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = (this_arg_conv->handle_reply_short_channel_ids_end)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
LDKQueryChannelRange msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = QueryChannelRange_clone(&msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = (this_arg_conv->handle_query_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
LDKQueryShortChannelIds msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = QueryShortChannelIds_clone(&msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = (this_arg_conv->handle_query_short_channel_ids)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_COption_TypeZDecodeErrorZ ret_conv = *(LDKCResult_COption_TypeZDecodeErrorZ*)(ret_ptr);
- ret_conv = CResult_COption_TypeZDecodeErrorZ_clone((LDKCResult_COption_TypeZDecodeErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
void* ret_conv_25_ptr = (void*)(((uint64_t)ret_conv_25) & ~1);
CHECK_ACCESS(ret_conv_25_ptr);
LDKC2Tuple_PublicKeyTypeZ ret_conv_25_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(ret_conv_25_ptr);
- ret_conv_25_conv = C2Tuple_PublicKeyTypeZ_clone((LDKC2Tuple_PublicKeyTypeZ*)(((uint64_t)ret_conv_25) & ~1));
+ FREE((void*)ret_conv_25);
ret_constr.data[z] = ret_conv_25_conv;
}
(*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
source_var = NodeId_clone(source);
CHECK((((uint64_t)source_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&source_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(source_var);
source_ref = (uint64_t)source_var.inner;
if (source_var.is_owned) {
source_ref |= 1;
target_var = NodeId_clone(target);
CHECK((((uint64_t)target_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&target_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(target_var);
target_ref = (uint64_t)target_var.inner;
if (target_var.is_owned) {
target_ref |= 1;
uint64_t path_conv_10_ref = 0;
CHECK((((uint64_t)path_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&path_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
path_conv_10_ref = (uint64_t)path_conv_10_var.inner;
if (path_conv_10_var.is_owned) {
path_conv_10_ref |= 1;
LDKNodeId source_conv;
source_conv.inner = (void*)(source & (~1));
source_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(source_conv);
LDKNodeId target_conv;
target_conv.inner = (void*)(target & (~1));
target_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
int64_t ret_val = (this_arg_conv->channel_penalty_msat)(this_arg_conv->this_arg, short_channel_id, &source_conv, &target_conv);
return ret_val;
}
LDKRouteHop path_conv_10_conv;
path_conv_10_conv.inner = (void*)(path_conv_10 & (~1));
path_conv_10_conv.is_owned = (path_conv_10 & 1) || (path_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
path_constr.data[k] = path_conv_10_conv;
}
// Warning: we may need a move here but no clone is available for LDKChannelManager
CHECK((((uint64_t)channel_manager_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&channel_manager_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_manager_var);
channel_manager_ref = (uint64_t)channel_manager_var.inner;
if (channel_manager_var.is_owned) {
channel_manager_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneErrorZ ret_conv = *(LDKCResult_NoneErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneErrorZ_clone((LDKCResult_NoneErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
LDKChannelManager channel_manager_conv;
channel_manager_conv.inner = (void*)(channel_manager & (~1));
channel_manager_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_manager_conv);
LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
*ret_conv = (this_arg_conv->persist_manager)(this_arg_conv->this_arg, &channel_manager_conv);
return (uint64_t)ret_conv;
LDKChannelDetails ret_conv_16_conv;
ret_conv_16_conv.inner = (void*)(ret_conv_16 & (~1));
ret_conv_16_conv.is_owned = (ret_conv_16 & 1) || (ret_conv_16 == 0);
- ret_conv_16_conv = ChannelDetails_clone(&ret_conv_16_conv);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_conv);
ret_constr.data[q] = ret_conv_16_conv;
}
(*env)->ReleaseLongArrayElements(env, ret, ret_vals, 0);
route_var = Route_clone(route);
CHECK((((uint64_t)route_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&route_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_var);
route_ref = (uint64_t)route_var.inner;
if (route_var.is_owned) {
route_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_PaymentIdPaymentSendFailureZ ret_conv = *(LDKCResult_PaymentIdPaymentSendFailureZ*)(ret_ptr);
- ret_conv = CResult_PaymentIdPaymentSendFailureZ_clone((LDKCResult_PaymentIdPaymentSendFailureZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
route_var = Route_clone(route);
CHECK((((uint64_t)route_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&route_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_var);
route_ref = (uint64_t)route_var.inner;
if (route_var.is_owned) {
route_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NonePaymentSendFailureZ ret_conv = *(LDKCResult_NonePaymentSendFailureZ*)(ret_ptr);
- ret_conv = CResult_NonePaymentSendFailureZ_clone((LDKCResult_NonePaymentSendFailureZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
uint64_t ret_conv_16_ref = 0;
CHECK((((uint64_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
ret_conv_16_ref = (uint64_t)ret_conv_16_var.inner;
if (ret_conv_16_var.is_owned) {
ret_conv_16_ref |= 1;
LDKRoute route_conv;
route_conv.inner = (void*)(route & (~1));
route_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
LDKThirtyTwoBytes payment_hash_ref;
CHECK((*env)->GetArrayLength(env, payment_hash) == 32);
(*env)->GetByteArrayRegion(env, payment_hash, 0, 32, payment_hash_ref.data);
LDKRoute route_conv;
route_conv.inner = (void*)(route & (~1));
route_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
LDKThirtyTwoBytes payment_id_ref;
CHECK((*env)->GetArrayLength(env, payment_id) == 32);
(*env)->GetByteArrayRegion(env, payment_id, 0, 32, payment_id_ref.data);
params_var = RouteParameters_clone(params);
CHECK((((uint64_t)params_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)¶ms_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(params_var);
params_ref = (uint64_t)params_var.inner;
if (params_var.is_owned) {
params_ref |= 1;
uint64_t first_hops_conv_16_ref = 0;
CHECK((((uint64_t)first_hops_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&first_hops_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_var);
first_hops_conv_16_ref = (uint64_t)first_hops_conv_16_var.inner;
if (first_hops_conv_16_var.is_owned) {
first_hops_conv_16_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_RouteLightningErrorZ ret_conv = *(LDKCResult_RouteLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_RouteLightningErrorZ_clone((LDKCResult_RouteLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
if (get_jenv_res == JNI_EDETACHED) {
DO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);
}
LDKRouteParameters params_conv;
params_conv.inner = (void*)(params & (~1));
params_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
LDKCVec_ChannelDetailsZ first_hops_constr;
LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL;
if (first_hops != NULL) {
LDKChannelDetails first_hops_conv_16_conv;
first_hops_conv_16_conv.inner = (void*)(first_hops_conv_16 & (~1));
first_hops_conv_16_conv.is_owned = (first_hops_conv_16 & 1) || (first_hops_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_conv);
first_hops_constr.data[q] = first_hops_conv_16_conv;
}
(*env)->ReleaseLongArrayElements(env, first_hops, first_hops_vals, 0);
TxOut_free(_res_conv);
}
+static inline uint64_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg) {
+ LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
+ *ret_ref = TxOut_clone(arg);
+ return (uint64_t)ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_TxOut_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKTxOut* arg_conv = (LDKTxOut*)(arg & ~1);
+ int64_t ret_val = TxOut_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_TxOut_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKTxOut* orig_conv = (LDKTxOut*)(orig & ~1);
LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1SecretKeyErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_SecretKeyErrorZ* o_conv = (LDKCResult_SecretKeyErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_SecretKeyErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SecretKeyErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PublicKeyErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_PublicKeyErrorZ* o_conv = (LDKCResult_PublicKeyErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PublicKeyErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PublicKeyErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PublicKeyErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
+ *ret_conv = CResult_PublicKeyErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PublicKeyErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_PublicKeyErrorZ* arg_conv = (LDKCResult_PublicKeyErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PublicKeyErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PublicKeyErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_PublicKeyErrorZ* orig_conv = (LDKCResult_PublicKeyErrorZ*)(orig & ~1);
LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
LDKTxCreationKeys o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = TxCreationKeys_clone(&o_conv);
LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
*ret_conv = CResult_TxCreationKeysDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
*ret_conv = CResult_TxCreationKeysDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_TxCreationKeysDecodeErrorZ* o_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_TxCreationKeysDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_TxCreationKeysDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
+ *ret_conv = CResult_TxCreationKeysDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_TxCreationKeysDecodeErrorZ* arg_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_TxCreationKeysDecodeErrorZ* orig_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)(orig & ~1);
LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
LDKChannelPublicKeys o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelPublicKeys_clone(&o_conv);
LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
*ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
*ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelPublicKeysDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ChannelPublicKeysDecodeErrorZ* o_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelPublicKeysDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelPublicKeysDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
+ *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelPublicKeysDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ChannelPublicKeysDecodeErrorZ* arg_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelPublicKeysDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ChannelPublicKeysDecodeErrorZ* orig_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
LDKTxCreationKeys o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = TxCreationKeys_clone(&o_conv);
LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
*ret_conv = CResult_TxCreationKeysErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_TxCreationKeysErrorZ* o_conv = (LDKCResult_TxCreationKeysErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_TxCreationKeysErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_TxCreationKeysErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_TxCreationKeysErrorZ_clone_ptr(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR arg) {
+ LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
+ *ret_conv = CResult_TxCreationKeysErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_TxCreationKeysErrorZ* arg_conv = (LDKCResult_TxCreationKeysErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_TxCreationKeysErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_TxCreationKeysErrorZ* orig_conv = (LDKCResult_TxCreationKeysErrorZ*)(orig & ~1);
LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
COption_u32Z_free(_res_conv);
}
+static inline uint64_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg) {
+ LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
+ *ret_copy = COption_u32Z_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1u32Z_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCOption_u32Z* arg_conv = (LDKCOption_u32Z*)arg;
+ int64_t ret_val = COption_u32Z_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1u32Z_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCOption_u32Z* orig_conv = (LDKCOption_u32Z*)orig;
LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
LDKHTLCOutputInCommitment o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = HTLCOutputInCommitment_clone(&o_conv);
LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
*ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
*ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCOutputInCommitmentDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* o_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCOutputInCommitmentDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
+ *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCOutputInCommitmentDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* arg_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCOutputInCommitmentDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* orig_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(orig & ~1);
LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
LDKCounterpartyChannelTransactionParameters o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = CounterpartyChannelTransactionParameters_clone(&o_conv);
LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
*ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
*ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* o_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
+ *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* arg_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(orig & ~1);
LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
LDKChannelTransactionParameters o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelTransactionParameters_clone(&o_conv);
LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
*ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
*ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelTransactionParametersDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ChannelTransactionParametersDecodeErrorZ* o_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelTransactionParametersDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelTransactionParametersDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
+ *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelTransactionParametersDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ChannelTransactionParametersDecodeErrorZ* arg_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelTransactionParametersDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
LDKHolderCommitmentTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = HolderCommitmentTransaction_clone(&o_conv);
LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1HolderCommitmentTransactionDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_HolderCommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1HolderCommitmentTransactionDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
+ *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HolderCommitmentTransactionDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_HolderCommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HolderCommitmentTransactionDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_HolderCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(orig & ~1);
LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
LDKBuiltCommitmentTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = BuiltCommitmentTransaction_clone(&o_conv);
LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1BuiltCommitmentTransactionDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1BuiltCommitmentTransactionDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
+ *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1BuiltCommitmentTransactionDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1BuiltCommitmentTransactionDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(orig & ~1);
LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
LDKTrustedClosingTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
// Warning: we need a move here but no clone is available for LDKTrustedClosingTransaction
LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
*ret_conv = CResult_TrustedClosingTransactionNoneZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedClosingTransactionNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_TrustedClosingTransactionNoneZ* o_conv = (LDKCResult_TrustedClosingTransactionNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_TrustedClosingTransactionNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedClosingTransactionNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKCommitmentTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = CommitmentTransaction_clone(&o_conv);
LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_CommitmentTransactionDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_CommitmentTransactionDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentTransactionDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_CommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CommitmentTransactionDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentTransactionDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CommitmentTransactionDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
+ *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentTransactionDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_CommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentTransactionDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_CommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(orig & ~1);
LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
LDKTrustedCommitmentTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
// Warning: we need a move here but no clone is available for LDKTrustedCommitmentTransaction
LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
*ret_conv = CResult_TrustedCommitmentTransactionNoneZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedCommitmentTransactionNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_TrustedCommitmentTransactionNoneZ* o_conv = (LDKCResult_TrustedCommitmentTransactionNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_TrustedCommitmentTransactionNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedCommitmentTransactionNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_CVec_SignatureZNoneZ* o_conv = (LDKCResult_CVec_SignatureZNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_CVec_SignatureZNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CVec_SignatureZNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg) {
+ LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
+ *ret_conv = CResult_CVec_SignatureZNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_CVec_SignatureZNoneZ* arg_conv = (LDKCResult_CVec_SignatureZNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_CVec_SignatureZNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_CVec_SignatureZNoneZ* orig_conv = (LDKCResult_CVec_SignatureZNoneZ*)(orig & ~1);
LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
LDKShutdownScript o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ShutdownScript_clone(&o_conv);
LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
*ret_conv = CResult_ShutdownScriptDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
*ret_conv = CResult_ShutdownScriptDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ShutdownScriptDecodeErrorZ* o_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ShutdownScriptDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ShutdownScriptDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
+ *ret_conv = CResult_ShutdownScriptDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ShutdownScriptDecodeErrorZ* arg_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ShutdownScriptDecodeErrorZ* orig_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)(orig & ~1);
LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
LDKShutdownScript o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ShutdownScript_clone(&o_conv);
LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
*ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o_conv);
LDKInvalidShutdownScript e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = InvalidShutdownScript_clone(&e_conv);
LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
*ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptInvalidShutdownScriptZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ShutdownScriptInvalidShutdownScriptZ* o_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(o & ~1);
+ jboolean ret_val = CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptInvalidShutdownScriptZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res_conv);
}
+static inline uint64_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg) {
+ LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
+ *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptInvalidShutdownScriptZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ShutdownScriptInvalidShutdownScriptZ* arg_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(arg & ~1);
+ int64_t ret_val = CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptInvalidShutdownScriptZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ShutdownScriptInvalidShutdownScriptZ* orig_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(orig & ~1);
LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NoneErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NoneErrorZ* o_conv = (LDKCResult_NoneErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
+ *ret_conv = CResult_NoneErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NoneErrorZ* arg_conv = (LDKCResult_NoneErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NoneErrorZ* orig_conv = (LDKCResult_NoneErrorZ*)(orig & ~1);
LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
LDKRouteHop o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RouteHop_clone(&o_conv);
LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
*ret_conv = CResult_RouteHopDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
*ret_conv = CResult_RouteHopDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHopDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_RouteHopDecodeErrorZ* o_conv = (LDKCResult_RouteHopDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteHopDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHopDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RouteHopDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
+ *ret_conv = CResult_RouteHopDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHopDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_RouteHopDecodeErrorZ* arg_conv = (LDKCResult_RouteHopDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteHopDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHopDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_RouteHopDecodeErrorZ* orig_conv = (LDKCResult_RouteHopDecodeErrorZ*)(orig & ~1);
LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
LDKRouteHop _res_conv_10_conv;
_res_conv_10_conv.inner = (void*)(_res_conv_10 & (~1));
_res_conv_10_conv.is_owned = (_res_conv_10 & 1) || (_res_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_10_conv);
_res_constr.data[k] = _res_conv_10_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
LDKRouteHop _res_conv_12_conv_10_conv;
_res_conv_12_conv_10_conv.inner = (void*)(_res_conv_12_conv_10 & (~1));
_res_conv_12_conv_10_conv.is_owned = (_res_conv_12_conv_10 & 1) || (_res_conv_12_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_12_conv_10_conv);
_res_conv_12_constr.data[k] = _res_conv_12_conv_10_conv;
}
(*env)->ReleaseLongArrayElements(env, _res_conv_12, _res_conv_12_vals, 0);
LDKRoute o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Route_clone(&o_conv);
LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
*ret_conv = CResult_RouteDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
*ret_conv = CResult_RouteDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RouteDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_RouteDecodeErrorZ* o_conv = (LDKCResult_RouteDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RouteDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
+ *ret_conv = CResult_RouteDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_RouteDecodeErrorZ* arg_conv = (LDKCResult_RouteDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_RouteDecodeErrorZ* orig_conv = (LDKCResult_RouteDecodeErrorZ*)(orig & ~1);
LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
LDKRouteParameters o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RouteParameters_clone(&o_conv);
LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
*ret_conv = CResult_RouteParametersDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
*ret_conv = CResult_RouteParametersDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RouteParametersDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_RouteParametersDecodeErrorZ* o_conv = (LDKCResult_RouteParametersDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteParametersDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteParametersDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RouteParametersDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
+ *ret_conv = CResult_RouteParametersDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteParametersDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_RouteParametersDecodeErrorZ* arg_conv = (LDKCResult_RouteParametersDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteParametersDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteParametersDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_RouteParametersDecodeErrorZ* orig_conv = (LDKCResult_RouteParametersDecodeErrorZ*)(orig & ~1);
LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
LDKRouteHint _res_conv_11_conv;
_res_conv_11_conv.inner = (void*)(_res_conv_11 & (~1));
_res_conv_11_conv.is_owned = (_res_conv_11 & 1) || (_res_conv_11 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_11_conv);
_res_constr.data[l] = _res_conv_11_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
COption_u64Z_free(_res_conv);
}
+static inline uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg) {
+ LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
+ *ret_copy = COption_u64Z_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1u64Z_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCOption_u64Z* arg_conv = (LDKCOption_u64Z*)arg;
+ int64_t ret_val = COption_u64Z_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1u64Z_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCOption_u64Z* orig_conv = (LDKCOption_u64Z*)orig;
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
LDKPayee o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Payee_clone(&o_conv);
LDKCResult_PayeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeeDecodeErrorZ), "LDKCResult_PayeeDecodeErrorZ");
*ret_conv = CResult_PayeeDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_PayeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeeDecodeErrorZ), "LDKCResult_PayeeDecodeErrorZ");
*ret_conv = CResult_PayeeDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PayeeDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_PayeeDecodeErrorZ* o_conv = (LDKCResult_PayeeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PayeeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PayeeDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PayeeDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PayeeDecodeErrorZ_clone_ptr(LDKCResult_PayeeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PayeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeeDecodeErrorZ), "LDKCResult_PayeeDecodeErrorZ");
+ *ret_conv = CResult_PayeeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PayeeDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_PayeeDecodeErrorZ* arg_conv = (LDKCResult_PayeeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PayeeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PayeeDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_PayeeDecodeErrorZ* orig_conv = (LDKCResult_PayeeDecodeErrorZ*)(orig & ~1);
LDKCResult_PayeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeeDecodeErrorZ), "LDKCResult_PayeeDecodeErrorZ");
LDKRouteHintHop _res_conv_14_conv;
_res_conv_14_conv.inner = (void*)(_res_conv_14 & (~1));
_res_conv_14_conv.is_owned = (_res_conv_14 & 1) || (_res_conv_14 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_14_conv);
_res_constr.data[o] = _res_conv_14_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
LDKRouteHint o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RouteHint_clone(&o_conv);
LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
*ret_conv = CResult_RouteHintDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
*ret_conv = CResult_RouteHintDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_RouteHintDecodeErrorZ* o_conv = (LDKCResult_RouteHintDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteHintDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RouteHintDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
+ *ret_conv = CResult_RouteHintDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_RouteHintDecodeErrorZ* arg_conv = (LDKCResult_RouteHintDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteHintDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_RouteHintDecodeErrorZ* orig_conv = (LDKCResult_RouteHintDecodeErrorZ*)(orig & ~1);
LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
LDKRouteHintHop o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RouteHintHop_clone(&o_conv);
LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
*ret_conv = CResult_RouteHintHopDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
*ret_conv = CResult_RouteHintHopDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintHopDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_RouteHintHopDecodeErrorZ* o_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteHintHopDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintHopDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RouteHintHopDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
+ *ret_conv = CResult_RouteHintHopDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintHopDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_RouteHintHopDecodeErrorZ* arg_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintHopDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_RouteHintHopDecodeErrorZ* orig_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)(orig & ~1);
LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
LDKChannelDetails _res_conv_16_conv;
_res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
_res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
_res_constr.data[q] = _res_conv_16_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
LDKRoute o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Route_clone(&o_conv);
LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
*ret_conv = CResult_RouteLightningErrorZ_ok(o_conv);
LDKLightningError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = LightningError_clone(&e_conv);
LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
*ret_conv = CResult_RouteLightningErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RouteLightningErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_RouteLightningErrorZ* o_conv = (LDKCResult_RouteLightningErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteLightningErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteLightningErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RouteLightningErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
+ *ret_conv = CResult_RouteLightningErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteLightningErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_RouteLightningErrorZ* arg_conv = (LDKCResult_RouteLightningErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteLightningErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RouteLightningErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_RouteLightningErrorZ* orig_conv = (LDKCResult_RouteLightningErrorZ*)(orig & ~1);
LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1TxOutAccessErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_TxOutAccessErrorZ* o_conv = (LDKCResult_TxOutAccessErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_TxOutAccessErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TxOutAccessErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_TxOutAccessErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg) {
+ LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
+ *ret_conv = CResult_TxOutAccessErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxOutAccessErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_TxOutAccessErrorZ* arg_conv = (LDKCResult_TxOutAccessErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_TxOutAccessErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TxOutAccessErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_TxOutAccessErrorZ* orig_conv = (LDKCResult_TxOutAccessErrorZ*)(orig & ~1);
LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg) {
+ LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
+ *ret_conv = C2Tuple_usizeTransactionZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1usizeTransactionZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC2Tuple_usizeTransactionZ* arg_conv = (LDKC2Tuple_usizeTransactionZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_usizeTransactionZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1usizeTransactionZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC2Tuple_usizeTransactionZ* orig_conv = (LDKC2Tuple_usizeTransactionZ*)(orig & ~1);
LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NoneChannelMonitorUpdateErrZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NoneChannelMonitorUpdateErrZ* o_conv = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneChannelMonitorUpdateErrZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneChannelMonitorUpdateErrZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneChannelMonitorUpdateErrZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR arg) {
+ LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
+ *ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneChannelMonitorUpdateErrZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NoneChannelMonitorUpdateErrZ* arg_conv = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneChannelMonitorUpdateErrZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NoneChannelMonitorUpdateErrZ* orig_conv = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(orig & ~1);
LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
COption_C2Tuple_usizeTransactionZZ_free(_res_conv);
}
+static inline uint64_t COption_C2Tuple_usizeTransactionZZ_clone_ptr(LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR arg) {
+ LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
+ *ret_copy = COption_C2Tuple_usizeTransactionZZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1C2Tuple_1usizeTransactionZZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCOption_C2Tuple_usizeTransactionZZ* arg_conv = (LDKCOption_C2Tuple_usizeTransactionZZ*)arg;
+ int64_t ret_val = COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1C2Tuple_1usizeTransactionZZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCOption_C2Tuple_usizeTransactionZZ* orig_conv = (LDKCOption_C2Tuple_usizeTransactionZZ*)orig;
LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
return ret_ref;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1ClosureReasonZ_1some(JNIEnv *env, jclass clz, int64_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKClosureReason o_conv = *(LDKClosureReason*)(o_ptr);
+ o_conv = ClosureReason_clone((LDKClosureReason*)(((uint64_t)o) & ~1));
+ LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
+ *ret_copy = COption_ClosureReasonZ_some(o_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1ClosureReasonZ_1none(JNIEnv *env, jclass clz) {
+ LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
+ *ret_copy = COption_ClosureReasonZ_none();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1ClosureReasonZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_ClosureReasonZ _res_conv = *(LDKCOption_ClosureReasonZ*)(_res_ptr);
+ FREE((void*)_res);
+ COption_ClosureReasonZ_free(_res_conv);
+}
+
+static inline uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg) {
+ LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
+ *ret_copy = COption_ClosureReasonZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1ClosureReasonZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCOption_ClosureReasonZ* arg_conv = (LDKCOption_ClosureReasonZ*)arg;
+ int64_t ret_val = COption_ClosureReasonZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1ClosureReasonZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+ LDKCOption_ClosureReasonZ* orig_conv = (LDKCOption_ClosureReasonZ*)orig;
+ LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
+ *ret_copy = COption_ClosureReasonZ_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1ClosureReasonZDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKCOption_ClosureReasonZ o_conv = *(LDKCOption_ClosureReasonZ*)(o_ptr);
+ o_conv = COption_ClosureReasonZ_clone((LDKCOption_ClosureReasonZ*)(((uint64_t)o) & ~1));
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1ClosureReasonZDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1ClosureReasonZDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* o_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1ClosureReasonZDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ _res_conv = *(LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_COption_ClosureReasonZDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1ClosureReasonZDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* arg_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1ClosureReasonZDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* orig_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(orig & ~1);
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1NetworkUpdateZ_1some(JNIEnv *env, jclass clz, int64_t o) {
void* o_ptr = (void*)(((uint64_t)o) & ~1);
CHECK_ACCESS(o_ptr);
COption_NetworkUpdateZ_free(_res_conv);
}
+static inline uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg) {
+ LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
+ *ret_copy = COption_NetworkUpdateZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1NetworkUpdateZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCOption_NetworkUpdateZ* arg_conv = (LDKCOption_NetworkUpdateZ*)arg;
+ int64_t ret_val = COption_NetworkUpdateZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1NetworkUpdateZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCOption_NetworkUpdateZ* orig_conv = (LDKCOption_NetworkUpdateZ*)orig;
LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
CVec_SpendableOutputDescriptorZ_free(_res_constr);
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1EventZ_1some(JNIEnv *env, jclass clz, int64_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKEvent o_conv = *(LDKEvent*)(o_ptr);
+ o_conv = Event_clone((LDKEvent*)(((uint64_t)o) & ~1));
+ LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
+ *ret_copy = COption_EventZ_some(o_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1EventZ_1none(JNIEnv *env, jclass clz) {
+ LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
+ *ret_copy = COption_EventZ_none();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1EventZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_EventZ _res_conv = *(LDKCOption_EventZ*)(_res_ptr);
+ FREE((void*)_res);
+ COption_EventZ_free(_res_conv);
+}
+
+static inline uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg) {
+ LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
+ *ret_copy = COption_EventZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1EventZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCOption_EventZ* arg_conv = (LDKCOption_EventZ*)arg;
+ int64_t ret_val = COption_EventZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1EventZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+ LDKCOption_EventZ* orig_conv = (LDKCOption_EventZ*)orig;
+ LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
+ *ret_copy = COption_EventZ_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1EventZDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKCOption_EventZ o_conv = *(LDKCOption_EventZ*)(o_ptr);
+ o_conv = COption_EventZ_clone((LDKCOption_EventZ*)(((uint64_t)o) & ~1));
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = CResult_COption_EventZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1EventZDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = CResult_COption_EventZDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1EventZDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_COption_EventZDecodeErrorZ* o_conv = (LDKCResult_COption_EventZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_EventZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1EventZDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_COption_EventZDecodeErrorZ _res_conv = *(LDKCResult_COption_EventZDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_COption_EventZDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = CResult_COption_EventZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1EventZDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_EventZDecodeErrorZ* arg_conv = (LDKCResult_COption_EventZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_EventZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1EventZDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+ LDKCResult_COption_EventZDecodeErrorZ* orig_conv = (LDKCResult_COption_EventZDecodeErrorZ*)(orig & ~1);
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = CResult_COption_EventZDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1MessageSendEventZ_1free(JNIEnv *env, jclass clz, int64_tArray _res) {
LDKCVec_MessageSendEventZ _res_constr;
_res_constr.datalen = (*env)->GetArrayLength(env, _res);
LDKInitFeatures o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = InitFeatures_clone(&o_conv);
LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
*ret_conv = CResult_InitFeaturesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
*ret_conv = CResult_InitFeaturesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1InitFeaturesDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_InitFeaturesDecodeErrorZ* o_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InitFeaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InitFeaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKNodeFeatures o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NodeFeatures_clone(&o_conv);
LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
*ret_conv = CResult_NodeFeaturesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
*ret_conv = CResult_NodeFeaturesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NodeFeaturesDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NodeFeaturesDecodeErrorZ* o_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeFeaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeFeaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKChannelFeatures o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelFeatures_clone(&o_conv);
LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
*ret_conv = CResult_ChannelFeaturesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
*ret_conv = CResult_ChannelFeaturesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelFeaturesDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ChannelFeaturesDecodeErrorZ* o_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelFeaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelFeaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKInvoiceFeatures o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = InvoiceFeatures_clone(&o_conv);
LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
*ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
*ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceFeaturesDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_InvoiceFeaturesDecodeErrorZ* o_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceFeaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKScoringParameters o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
// Warning: we need a move here but no clone is available for LDKScoringParameters
LDKCResult_ScoringParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ScoringParametersDecodeErrorZ), "LDKCResult_ScoringParametersDecodeErrorZ");
*ret_conv = CResult_ScoringParametersDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ScoringParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ScoringParametersDecodeErrorZ), "LDKCResult_ScoringParametersDecodeErrorZ");
*ret_conv = CResult_ScoringParametersDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ScoringParametersDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ScoringParametersDecodeErrorZ* o_conv = (LDKCResult_ScoringParametersDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ScoringParametersDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ScoringParametersDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKScorer o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
// Warning: we need a move here but no clone is available for LDKScorer
LDKCResult_ScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ScorerDecodeErrorZ), "LDKCResult_ScorerDecodeErrorZ");
*ret_conv = CResult_ScorerDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ScorerDecodeErrorZ), "LDKCResult_ScorerDecodeErrorZ");
*ret_conv = CResult_ScorerDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ScorerDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ScorerDecodeErrorZ* o_conv = (LDKCResult_ScorerDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ScorerDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ScorerDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKDelayedPaymentOutputDescriptor o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = DelayedPaymentOutputDescriptor_clone(&o_conv);
LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
*ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
*ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(orig & ~1);
LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
LDKStaticPaymentOutputDescriptor o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = StaticPaymentOutputDescriptor_clone(&o_conv);
LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
*ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
*ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(orig & ~1);
LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
*ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1SpendableOutputDescriptorDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SpendableOutputDescriptorDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SpendableOutputDescriptorDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SpendableOutputDescriptorDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_SpendableOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(orig & ~1);
LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NoneNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NoneNoneZ* o_conv = (LDKCResult_NoneNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg) {
+ LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
+ *ret_conv = CResult_NoneNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneNoneZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NoneNoneZ* arg_conv = (LDKCResult_NoneNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NoneNoneZ* orig_conv = (LDKCResult_NoneNoneZ*)(orig & ~1);
LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg) {
+ LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
+ *ret_conv = C2Tuple_SignatureCVec_SignatureZZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1SignatureCVec_1SignatureZZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC2Tuple_SignatureCVec_SignatureZZ* arg_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1SignatureCVec_1SignatureZZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC2Tuple_SignatureCVec_SignatureZZ* orig_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(orig & ~1);
LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* o_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg) {
+ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
+ *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* arg_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* orig_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(orig & ~1);
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1SignatureNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_SignatureNoneZ* o_conv = (LDKCResult_SignatureNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_SignatureNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SignatureNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_SignatureNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg) {
+ LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
+ *ret_conv = CResult_SignatureNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignatureNoneZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_SignatureNoneZ* arg_conv = (LDKCResult_SignatureNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_SignatureNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignatureNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_SignatureNoneZ* orig_conv = (LDKCResult_SignatureNoneZ*)(orig & ~1);
LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
*ret_conv = CResult_SignDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1SignDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_SignDecodeErrorZ* o_conv = (LDKCResult_SignDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_SignDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SignDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_SignDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
+ *ret_conv = CResult_SignDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_SignDecodeErrorZ* arg_conv = (LDKCResult_SignDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_SignDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_SignDecodeErrorZ* orig_conv = (LDKCResult_SignDecodeErrorZ*)(orig & ~1);
LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RecoverableSignatureNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_RecoverableSignatureNoneZ* o_conv = (LDKCResult_RecoverableSignatureNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_RecoverableSignatureNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RecoverableSignatureNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RecoverableSignatureNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg) {
+ LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
+ *ret_conv = CResult_RecoverableSignatureNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RecoverableSignatureNoneZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_RecoverableSignatureNoneZ* arg_conv = (LDKCResult_RecoverableSignatureNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_RecoverableSignatureNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RecoverableSignatureNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_RecoverableSignatureNoneZ* orig_conv = (LDKCResult_RecoverableSignatureNoneZ*)(orig & ~1);
LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1CVec_1u8ZZNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_CVec_CVec_u8ZZNoneZ* o_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_CVec_CVec_u8ZZNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1CVec_1u8ZZNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CVec_CVec_u8ZZNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg) {
+ LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
+ *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1CVec_1u8ZZNoneZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_CVec_CVec_u8ZZNoneZ* arg_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1CVec_1u8ZZNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_CVec_CVec_u8ZZNoneZ* orig_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(orig & ~1);
LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
LDKInMemorySigner o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = InMemorySigner_clone(&o_conv);
LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
*ret_conv = CResult_InMemorySignerDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
*ret_conv = CResult_InMemorySignerDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1InMemorySignerDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_InMemorySignerDecodeErrorZ* o_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InMemorySignerDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InMemorySignerDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_InMemorySignerDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
+ *ret_conv = CResult_InMemorySignerDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InMemorySignerDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_InMemorySignerDecodeErrorZ* arg_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InMemorySignerDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_InMemorySignerDecodeErrorZ* orig_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(orig & ~1);
LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1TransactionNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_TransactionNoneZ* o_conv = (LDKCResult_TransactionNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_TransactionNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TransactionNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_TransactionNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg) {
+ LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
+ *ret_conv = CResult_TransactionNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TransactionNoneZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_TransactionNoneZ* arg_conv = (LDKCResult_TransactionNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_TransactionNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1TransactionNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_TransactionNoneZ* orig_conv = (LDKCResult_TransactionNoneZ*)(orig & ~1);
LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg) {
+ LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
+ *ret_conv = C2Tuple_BlockHashChannelMonitorZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1BlockHashChannelMonitorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC2Tuple_BlockHashChannelMonitorZ* arg_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1BlockHashChannelMonitorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC2Tuple_BlockHashChannelMonitorZ* orig_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)(orig & ~1);
LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
LDKChannelMonitor b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = (b & 1) || (b == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
b_conv = ChannelMonitor_clone(&b_conv);
LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
*ret_conv = C2Tuple_BlockHashChannelMonitorZ_new(a_ref, b_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* o_conv = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone_ptr(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ), "LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ");
+ *ret_conv = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* arg_conv = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* orig_conv = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(orig & ~1);
LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ), "LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ");
COption_u16Z_free(_res_conv);
}
+static inline uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg) {
+ LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
+ *ret_copy = COption_u16Z_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1u16Z_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCOption_u16Z* arg_conv = (LDKCOption_u16Z*)arg;
+ int64_t ret_val = COption_u16Z_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1u16Z_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCOption_u16Z* orig_conv = (LDKCOption_u16Z*)orig;
LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NoneAPIErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NoneAPIErrorZ* o_conv = (LDKCResult_NoneAPIErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneAPIErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneAPIErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneAPIErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
+ *ret_conv = CResult_NoneAPIErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneAPIErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NoneAPIErrorZ* arg_conv = (LDKCResult_NoneAPIErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneAPIErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneAPIErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NoneAPIErrorZ* orig_conv = (LDKCResult_NoneAPIErrorZ*)(orig & ~1);
LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1_1u832APIErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult__u832APIErrorZ* o_conv = (LDKCResult__u832APIErrorZ*)(o & ~1);
+ jboolean ret_val = CResult__u832APIErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1_1u832APIErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult__u832APIErrorZ_free(_res_conv);
}
+static inline uint64_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg) {
+ LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
+ *ret_conv = CResult__u832APIErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1_1u832APIErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult__u832APIErrorZ* arg_conv = (LDKCResult__u832APIErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult__u832APIErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1_1u832APIErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult__u832APIErrorZ* orig_conv = (LDKCResult__u832APIErrorZ*)(orig & ~1);
LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentSendFailureZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_PaymentIdPaymentSendFailureZ* o_conv = (LDKCResult_PaymentIdPaymentSendFailureZ*)(o & ~1);
+ jboolean ret_val = CResult_PaymentIdPaymentSendFailureZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentSendFailureZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PaymentIdPaymentSendFailureZ_free(_res_conv);
}
+static inline uint64_t CResult_PaymentIdPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR arg) {
+ LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ");
+ *ret_conv = CResult_PaymentIdPaymentSendFailureZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentSendFailureZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_PaymentIdPaymentSendFailureZ* arg_conv = (LDKCResult_PaymentIdPaymentSendFailureZ*)(arg & ~1);
+ int64_t ret_val = CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentSendFailureZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_PaymentIdPaymentSendFailureZ* orig_conv = (LDKCResult_PaymentIdPaymentSendFailureZ*)(orig & ~1);
LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NonePaymentSendFailureZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NonePaymentSendFailureZ* o_conv = (LDKCResult_NonePaymentSendFailureZ*)(o & ~1);
+ jboolean ret_val = CResult_NonePaymentSendFailureZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NonePaymentSendFailureZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NonePaymentSendFailureZ_free(_res_conv);
}
+static inline uint64_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg) {
+ LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
+ *ret_conv = CResult_NonePaymentSendFailureZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NonePaymentSendFailureZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NonePaymentSendFailureZ* arg_conv = (LDKCResult_NonePaymentSendFailureZ*)(arg & ~1);
+ int64_t ret_val = CResult_NonePaymentSendFailureZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NonePaymentSendFailureZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NonePaymentSendFailureZ* orig_conv = (LDKCResult_NonePaymentSendFailureZ*)(orig & ~1);
LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg) {
+ LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
+ *ret_conv = C2Tuple_PaymentHashPaymentIdZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1PaymentHashPaymentIdZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC2Tuple_PaymentHashPaymentIdZ* arg_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1PaymentHashPaymentIdZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC2Tuple_PaymentHashPaymentIdZ* orig_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)(orig & ~1);
LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1PaymentHashPaymentIdZPaymentSendFailureZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* o_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(o & ~1);
+ jboolean ret_val = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1PaymentHashPaymentIdZPaymentSendFailureZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res_conv);
}
+static inline uint64_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg) {
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
+ *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1PaymentHashPaymentIdZPaymentSendFailureZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* arg_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(arg & ~1);
+ int64_t ret_val = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1PaymentHashPaymentIdZPaymentSendFailureZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* orig_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(orig & ~1);
LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
CVec_NetAddressZ_free(_res_constr);
}
+static inline uint64_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg) {
+ LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
+ *ret_conv = C2Tuple_PaymentHashPaymentSecretZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1PaymentHashPaymentSecretZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC2Tuple_PaymentHashPaymentSecretZ* arg_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1PaymentHashPaymentSecretZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC2Tuple_PaymentHashPaymentSecretZ* orig_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(orig & ~1);
LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentSecretAPIErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_PaymentSecretAPIErrorZ* o_conv = (LDKCResult_PaymentSecretAPIErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PaymentSecretAPIErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentSecretAPIErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PaymentSecretAPIErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
+ *ret_conv = CResult_PaymentSecretAPIErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentSecretAPIErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_PaymentSecretAPIErrorZ* arg_conv = (LDKCResult_PaymentSecretAPIErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PaymentSecretAPIErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentSecretAPIErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_PaymentSecretAPIErrorZ* orig_conv = (LDKCResult_PaymentSecretAPIErrorZ*)(orig & ~1);
LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
LDKChannelMonitor _res_conv_16_conv;
_res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
_res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
_res_constr.data[q] = _res_conv_16_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
LDKChannelManager b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = (b & 1) || (b == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
// Warning: we need a move here but no clone is available for LDKChannelManager
LDKC2Tuple_BlockHashChannelManagerZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelManagerZ), "LDKC2Tuple_BlockHashChannelManagerZ");
*ret_conv = C2Tuple_BlockHashChannelManagerZ_new(a_ref, b_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
*ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* o_conv = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKChannelConfig o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelConfig_clone(&o_conv);
LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
*ret_conv = CResult_ChannelConfigDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
*ret_conv = CResult_ChannelConfigDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ChannelConfigDecodeErrorZ* o_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelConfigDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelConfigDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
+ *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ChannelConfigDecodeErrorZ* arg_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ChannelConfigDecodeErrorZ* orig_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
LDKOutPoint o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = OutPoint_clone(&o_conv);
LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
*ret_conv = CResult_OutPointDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
*ret_conv = CResult_OutPointDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1OutPointDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_OutPointDecodeErrorZ* o_conv = (LDKCResult_OutPointDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_OutPointDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1OutPointDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_OutPointDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
+ *ret_conv = CResult_OutPointDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OutPointDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_OutPointDecodeErrorZ* arg_conv = (LDKCResult_OutPointDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_OutPointDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OutPointDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_OutPointDecodeErrorZ* orig_conv = (LDKCResult_OutPointDecodeErrorZ*)(orig & ~1);
LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
COption_TypeZ_free(_res_conv);
}
+static inline uint64_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg) {
+ LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
+ *ret_copy = COption_TypeZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1TypeZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCOption_TypeZ* arg_conv = (LDKCOption_TypeZ*)arg;
+ int64_t ret_val = COption_TypeZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1TypeZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCOption_TypeZ* orig_conv = (LDKCOption_TypeZ*)orig;
LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
*ret_conv = CResult_COption_TypeZDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1TypeZDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_COption_TypeZDecodeErrorZ* o_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_TypeZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1TypeZDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_COption_TypeZDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
+ *ret_conv = CResult_COption_TypeZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1TypeZDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_TypeZDecodeErrorZ* arg_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1TypeZDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_COption_TypeZDecodeErrorZ* orig_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)(orig & ~1);
LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_PaymentIdPaymentErrorZ* o_conv = (LDKCResult_PaymentIdPaymentErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PaymentIdPaymentErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PaymentIdPaymentErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
+ *ret_conv = CResult_PaymentIdPaymentErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_PaymentIdPaymentErrorZ* arg_conv = (LDKCResult_PaymentIdPaymentErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PaymentIdPaymentErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_PaymentIdPaymentErrorZ* orig_conv = (LDKCResult_PaymentIdPaymentErrorZ*)(orig & ~1);
LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1SiPrefixNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_SiPrefixNoneZ* o_conv = (LDKCResult_SiPrefixNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_SiPrefixNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SiPrefixNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_SiPrefixNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_SiPrefixNoneZ_clone_ptr(LDKCResult_SiPrefixNoneZ *NONNULL_PTR arg) {
+ LDKCResult_SiPrefixNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixNoneZ), "LDKCResult_SiPrefixNoneZ");
+ *ret_conv = CResult_SiPrefixNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SiPrefixNoneZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_SiPrefixNoneZ* arg_conv = (LDKCResult_SiPrefixNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_SiPrefixNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SiPrefixNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_SiPrefixNoneZ* orig_conv = (LDKCResult_SiPrefixNoneZ*)(orig & ~1);
LDKCResult_SiPrefixNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixNoneZ), "LDKCResult_SiPrefixNoneZ");
LDKInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Invoice_clone(&o_conv);
LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
*ret_conv = CResult_InvoiceNoneZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_InvoiceNoneZ* o_conv = (LDKCResult_InvoiceNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_InvoiceNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_InvoiceNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_InvoiceNoneZ_clone_ptr(LDKCResult_InvoiceNoneZ *NONNULL_PTR arg) {
+ LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
+ *ret_conv = CResult_InvoiceNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceNoneZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_InvoiceNoneZ* arg_conv = (LDKCResult_InvoiceNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_InvoiceNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_InvoiceNoneZ* orig_conv = (LDKCResult_InvoiceNoneZ*)(orig & ~1);
LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
LDKSignedRawInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = SignedRawInvoice_clone(&o_conv);
LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
*ret_conv = CResult_SignedRawInvoiceNoneZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1SignedRawInvoiceNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_SignedRawInvoiceNoneZ* o_conv = (LDKCResult_SignedRawInvoiceNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_SignedRawInvoiceNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SignedRawInvoiceNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_SignedRawInvoiceNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_SignedRawInvoiceNoneZ_clone_ptr(LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR arg) {
+ LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
+ *ret_conv = CResult_SignedRawInvoiceNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignedRawInvoiceNoneZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_SignedRawInvoiceNoneZ* arg_conv = (LDKCResult_SignedRawInvoiceNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_SignedRawInvoiceNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1SignedRawInvoiceNoneZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_SignedRawInvoiceNoneZ* orig_conv = (LDKCResult_SignedRawInvoiceNoneZ*)(orig & ~1);
LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg) {
+ LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
+ *ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C3Tuple_1RawInvoice_1u832InvoiceSignatureZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* arg_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(arg & ~1);
+ int64_t ret_val = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C3Tuple_1RawInvoice_1u832InvoiceSignatureZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* orig_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(orig & ~1);
LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
LDKRawInvoice a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = RawInvoice_clone(&a_conv);
LDKThirtyTwoBytes b_ref;
CHECK((*env)->GetArrayLength(env, b) == 32);
LDKInvoiceSignature c_conv;
c_conv.inner = (void*)(c & (~1));
c_conv.is_owned = (c & 1) || (c == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(c_conv);
c_conv = InvoiceSignature_clone(&c_conv);
LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
*ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a_conv, b_ref, c_conv);
LDKPayeePubKey o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = PayeePubKey_clone(&o_conv);
LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
*ret_conv = CResult_PayeePubKeyErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PayeePubKeyErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_PayeePubKeyErrorZ* o_conv = (LDKCResult_PayeePubKeyErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PayeePubKeyErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PayeePubKeyErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PayeePubKeyErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
+ *ret_conv = CResult_PayeePubKeyErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PayeePubKeyErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_PayeePubKeyErrorZ* arg_conv = (LDKCResult_PayeePubKeyErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PayeePubKeyErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PayeePubKeyErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_PayeePubKeyErrorZ* orig_conv = (LDKCResult_PayeePubKeyErrorZ*)(orig & ~1);
LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
LDKPrivateRoute _res_conv_14_conv;
_res_conv_14_conv.inner = (void*)(_res_conv_14 & (~1));
_res_conv_14_conv.is_owned = (_res_conv_14 & 1) || (_res_conv_14 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_14_conv);
_res_constr.data[o] = _res_conv_14_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
LDKPositiveTimestamp o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = PositiveTimestamp_clone(&o_conv);
LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
*ret_conv = CResult_PositiveTimestampCreationErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PositiveTimestampCreationErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_PositiveTimestampCreationErrorZ* o_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PositiveTimestampCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PositiveTimestampCreationErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PositiveTimestampCreationErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
+ *ret_conv = CResult_PositiveTimestampCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PositiveTimestampCreationErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_PositiveTimestampCreationErrorZ* arg_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PositiveTimestampCreationErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_PositiveTimestampCreationErrorZ* orig_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)(orig & ~1);
LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NoneSemanticErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NoneSemanticErrorZ* o_conv = (LDKCResult_NoneSemanticErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneSemanticErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneSemanticErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneSemanticErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
+ *ret_conv = CResult_NoneSemanticErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneSemanticErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NoneSemanticErrorZ* arg_conv = (LDKCResult_NoneSemanticErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneSemanticErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneSemanticErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NoneSemanticErrorZ* orig_conv = (LDKCResult_NoneSemanticErrorZ*)(orig & ~1);
LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
LDKInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Invoice_clone(&o_conv);
LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
*ret_conv = CResult_InvoiceSemanticErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSemanticErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_InvoiceSemanticErrorZ* o_conv = (LDKCResult_InvoiceSemanticErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InvoiceSemanticErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSemanticErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_InvoiceSemanticErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg) {
+ LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
+ *ret_conv = CResult_InvoiceSemanticErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSemanticErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_InvoiceSemanticErrorZ* arg_conv = (LDKCResult_InvoiceSemanticErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_InvoiceSemanticErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSemanticErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_InvoiceSemanticErrorZ* orig_conv = (LDKCResult_InvoiceSemanticErrorZ*)(orig & ~1);
LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
LDKDescription o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Description_clone(&o_conv);
LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
*ret_conv = CResult_DescriptionCreationErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1DescriptionCreationErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_DescriptionCreationErrorZ* o_conv = (LDKCResult_DescriptionCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_DescriptionCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1DescriptionCreationErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_DescriptionCreationErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
+ *ret_conv = CResult_DescriptionCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DescriptionCreationErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_DescriptionCreationErrorZ* arg_conv = (LDKCResult_DescriptionCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_DescriptionCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DescriptionCreationErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_DescriptionCreationErrorZ* orig_conv = (LDKCResult_DescriptionCreationErrorZ*)(orig & ~1);
LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
LDKExpiryTime o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ExpiryTime_clone(&o_conv);
LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
*ret_conv = CResult_ExpiryTimeCreationErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ExpiryTimeCreationErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ExpiryTimeCreationErrorZ* o_conv = (LDKCResult_ExpiryTimeCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ExpiryTimeCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ExpiryTimeCreationErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ExpiryTimeCreationErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ExpiryTimeCreationErrorZ_clone_ptr(LDKCResult_ExpiryTimeCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
+ *ret_conv = CResult_ExpiryTimeCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ExpiryTimeCreationErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ExpiryTimeCreationErrorZ* arg_conv = (LDKCResult_ExpiryTimeCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ExpiryTimeCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ExpiryTimeCreationErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ExpiryTimeCreationErrorZ* orig_conv = (LDKCResult_ExpiryTimeCreationErrorZ*)(orig & ~1);
LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
LDKPrivateRoute o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = PrivateRoute_clone(&o_conv);
LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
*ret_conv = CResult_PrivateRouteCreationErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PrivateRouteCreationErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_PrivateRouteCreationErrorZ* o_conv = (LDKCResult_PrivateRouteCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PrivateRouteCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PrivateRouteCreationErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PrivateRouteCreationErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
+ *ret_conv = CResult_PrivateRouteCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PrivateRouteCreationErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_PrivateRouteCreationErrorZ* arg_conv = (LDKCResult_PrivateRouteCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PrivateRouteCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PrivateRouteCreationErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_PrivateRouteCreationErrorZ* orig_conv = (LDKCResult_PrivateRouteCreationErrorZ*)(orig & ~1);
LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1StringErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_StringErrorZ* o_conv = (LDKCResult_StringErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_StringErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1StringErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKChannelMonitorUpdate o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelMonitorUpdate_clone(&o_conv);
LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
*ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
*ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* o_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
+ *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* arg_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ChannelMonitorUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1MonitorEventZ_1some(JNIEnv *env, jclass clz, int64_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKMonitorEvent o_conv = *(LDKMonitorEvent*)(o_ptr);
+ o_conv = MonitorEvent_clone((LDKMonitorEvent*)(((uint64_t)o) & ~1));
+ LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
+ *ret_copy = COption_MonitorEventZ_some(o_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1MonitorEventZ_1none(JNIEnv *env, jclass clz) {
+ LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
+ *ret_copy = COption_MonitorEventZ_none();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1MonitorEventZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_MonitorEventZ _res_conv = *(LDKCOption_MonitorEventZ*)(_res_ptr);
+ FREE((void*)_res);
+ COption_MonitorEventZ_free(_res_conv);
+}
+
+static inline uint64_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg) {
+ LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
+ *ret_copy = COption_MonitorEventZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1MonitorEventZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCOption_MonitorEventZ* arg_conv = (LDKCOption_MonitorEventZ*)arg;
+ int64_t ret_val = COption_MonitorEventZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1MonitorEventZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+ LDKCOption_MonitorEventZ* orig_conv = (LDKCOption_MonitorEventZ*)orig;
+ LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
+ *ret_copy = COption_MonitorEventZ_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1MonitorEventZDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKCOption_MonitorEventZ o_conv = *(LDKCOption_MonitorEventZ*)(o_ptr);
+ o_conv = COption_MonitorEventZ_clone((LDKCOption_MonitorEventZ*)(((uint64_t)o) & ~1));
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1MonitorEventZDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1MonitorEventZDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* o_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1MonitorEventZDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_COption_MonitorEventZDecodeErrorZ _res_conv = *(LDKCResult_COption_MonitorEventZDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_COption_MonitorEventZDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1MonitorEventZDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* arg_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1MonitorEventZDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* orig_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(orig & ~1);
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCUpdateDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
LDKHTLCUpdate o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = HTLCUpdate_clone(&o_conv);
LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
*ret_conv = CResult_HTLCUpdateDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
*ret_conv = CResult_HTLCUpdateDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCUpdateDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_HTLCUpdateDecodeErrorZ* o_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_HTLCUpdateDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCUpdateDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_HTLCUpdateDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
+ *ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCUpdateDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_HTLCUpdateDecodeErrorZ* arg_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCUpdateDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_HTLCUpdateDecodeErrorZ* orig_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(orig & ~1);
LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
LDKMonitorUpdateError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = MonitorUpdateError_clone(&e_conv);
LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
*ret_conv = CResult_NoneMonitorUpdateErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NoneMonitorUpdateErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NoneMonitorUpdateErrorZ* o_conv = (LDKCResult_NoneMonitorUpdateErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneMonitorUpdateErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneMonitorUpdateErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneMonitorUpdateErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneMonitorUpdateErrorZ_clone_ptr(LDKCResult_NoneMonitorUpdateErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
+ *ret_conv = CResult_NoneMonitorUpdateErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneMonitorUpdateErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NoneMonitorUpdateErrorZ* arg_conv = (LDKCResult_NoneMonitorUpdateErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneMonitorUpdateErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneMonitorUpdateErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NoneMonitorUpdateErrorZ* orig_conv = (LDKCResult_NoneMonitorUpdateErrorZ*)(orig & ~1);
LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg) {
+ LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
+ *ret_conv = C2Tuple_OutPointScriptZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1OutPointScriptZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC2Tuple_OutPointScriptZ* arg_conv = (LDKC2Tuple_OutPointScriptZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_OutPointScriptZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1OutPointScriptZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC2Tuple_OutPointScriptZ* orig_conv = (LDKC2Tuple_OutPointScriptZ*)(orig & ~1);
LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
LDKOutPoint a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = OutPoint_clone(&a_conv);
LDKCVec_u8Z b_ref;
b_ref.datalen = (*env)->GetArrayLength(env, b);
C2Tuple_OutPointScriptZ_free(_res_conv);
}
+static inline uint64_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg) {
+ LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
+ *ret_conv = C2Tuple_u32ScriptZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32ScriptZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC2Tuple_u32ScriptZ* arg_conv = (LDKC2Tuple_u32ScriptZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_u32ScriptZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32ScriptZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC2Tuple_u32ScriptZ* orig_conv = (LDKC2Tuple_u32ScriptZ*)(orig & ~1);
LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
CVec_C2Tuple_u32ScriptZZ_free(_res_constr);
}
+static inline uint64_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg) {
+ LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
+ *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* arg_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(orig & ~1);
LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
CVec_TransactionZ_free(_res_constr);
}
+static inline uint64_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg) {
+ LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
+ *ret_conv = C2Tuple_u32TxOutZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32TxOutZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC2Tuple_u32TxOutZ* arg_conv = (LDKC2Tuple_u32TxOutZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_u32TxOutZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32TxOutZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC2Tuple_u32TxOutZ* orig_conv = (LDKC2Tuple_u32TxOutZ*)(orig & ~1);
LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
CVec_C2Tuple_u32TxOutZZ_free(_res_constr);
}
+static inline uint64_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg) {
+ LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
+ *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* arg_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(orig & ~1);
LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
*ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* o_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
+ *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* arg_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* orig_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(orig & ~1);
LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
LDKLightningError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = LightningError_clone(&e_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = CResult_NoneLightningErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NoneLightningErrorZ* o_conv = (LDKCResult_NoneLightningErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneLightningErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneLightningErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
+ *ret_conv = CResult_NoneLightningErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NoneLightningErrorZ* arg_conv = (LDKCResult_NoneLightningErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneLightningErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NoneLightningErrorZ* orig_conv = (LDKCResult_NoneLightningErrorZ*)(orig & ~1);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg) {
+ LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
+ *ret_conv = C2Tuple_PublicKeyTypeZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1PublicKeyTypeZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC2Tuple_PublicKeyTypeZ* arg_conv = (LDKC2Tuple_PublicKeyTypeZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_PublicKeyTypeZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C2Tuple_1PublicKeyTypeZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC2Tuple_PublicKeyTypeZ* orig_conv = (LDKC2Tuple_PublicKeyTypeZ*)(orig & ~1);
LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
LDKLightningError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = LightningError_clone(&e_conv);
LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
*ret_conv = CResult_boolLightningErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_boolLightningErrorZ* o_conv = (LDKCResult_boolLightningErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_boolLightningErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_boolLightningErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg) {
+ LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
+ *ret_conv = CResult_boolLightningErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_boolLightningErrorZ* arg_conv = (LDKCResult_boolLightningErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_boolLightningErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_boolLightningErrorZ* orig_conv = (LDKCResult_boolLightningErrorZ*)(orig & ~1);
LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg) {
+ LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
+ *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* arg_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(arg & ~1);
+ int64_t ret_val = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* orig_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(orig & ~1);
LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
LDKChannelAnnouncement a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = ChannelAnnouncement_clone(&a_conv);
LDKChannelUpdate b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = (b & 1) || (b == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
b_conv = ChannelUpdate_clone(&b_conv);
LDKChannelUpdate c_conv;
c_conv.inner = (void*)(c & (~1));
c_conv.is_owned = (c & 1) || (c == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(c_conv);
c_conv = ChannelUpdate_clone(&c_conv);
LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
*ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a_conv, b_conv, c_conv);
LDKNodeAnnouncement _res_conv_18_conv;
_res_conv_18_conv.inner = (void*)(_res_conv_18 & (~1));
_res_conv_18_conv.is_owned = (_res_conv_18 & 1) || (_res_conv_18 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_18_conv);
_res_constr.data[s] = _res_conv_18_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
LDKPeerHandleError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = PeerHandleError_clone(&e_conv);
LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
*ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1u8ZPeerHandleErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_CVec_u8ZPeerHandleErrorZ* o_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1u8ZPeerHandleErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CVec_u8ZPeerHandleErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
+ *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1u8ZPeerHandleErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_CVec_u8ZPeerHandleErrorZ* arg_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1u8ZPeerHandleErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_CVec_u8ZPeerHandleErrorZ* orig_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(orig & ~1);
LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
LDKPeerHandleError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = PeerHandleError_clone(&e_conv);
LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
*ret_conv = CResult_NonePeerHandleErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NonePeerHandleErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NonePeerHandleErrorZ* o_conv = (LDKCResult_NonePeerHandleErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NonePeerHandleErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NonePeerHandleErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NonePeerHandleErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
+ *ret_conv = CResult_NonePeerHandleErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NonePeerHandleErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NonePeerHandleErrorZ* arg_conv = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NonePeerHandleErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NonePeerHandleErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NonePeerHandleErrorZ* orig_conv = (LDKCResult_NonePeerHandleErrorZ*)(orig & ~1);
LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
LDKPeerHandleError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = PeerHandleError_clone(&e_conv);
LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
*ret_conv = CResult_boolPeerHandleErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1boolPeerHandleErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_boolPeerHandleErrorZ* o_conv = (LDKCResult_boolPeerHandleErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_boolPeerHandleErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1boolPeerHandleErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_boolPeerHandleErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg) {
+ LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
+ *ret_conv = CResult_boolPeerHandleErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolPeerHandleErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_boolPeerHandleErrorZ* arg_conv = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_boolPeerHandleErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1boolPeerHandleErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_boolPeerHandleErrorZ* orig_conv = (LDKCResult_boolPeerHandleErrorZ*)(orig & ~1);
LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
LDKNodeId o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NodeId_clone(&o_conv);
LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
*ret_conv = CResult_NodeIdDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
*ret_conv = CResult_NodeIdDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NodeIdDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NodeIdDecodeErrorZ* o_conv = (LDKCResult_NodeIdDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeIdDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeIdDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NodeIdDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
+ *ret_conv = CResult_NodeIdDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeIdDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NodeIdDecodeErrorZ* arg_conv = (LDKCResult_NodeIdDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NodeIdDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeIdDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NodeIdDecodeErrorZ* orig_conv = (LDKCResult_NodeIdDecodeErrorZ*)(orig & ~1);
LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
return (uint64_t)ret_conv;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1NetworkUpdateZDecodeErrorZ_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKCOption_NetworkUpdateZ o_conv = *(LDKCOption_NetworkUpdateZ*)(o_ptr);
+ o_conv = COption_NetworkUpdateZ_clone((LDKCOption_NetworkUpdateZ*)(((uint64_t)o) & ~1));
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1NetworkUpdateZDecodeErrorZ_1err(JNIEnv *env, jclass clz, int64_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1NetworkUpdateZDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* o_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1NetworkUpdateZDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res_conv = *(LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1NetworkUpdateZDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* arg_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1NetworkUpdateZDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* orig_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(orig & ~1);
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1AccessZ_1some(JNIEnv *env, jclass clz, int64_t o) {
void* o_ptr = (void*)(((uint64_t)o) & ~1);
CHECK_ACCESS(o_ptr);
LDKDirectionalChannelInfo o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = DirectionalChannelInfo_clone(&o_conv);
LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
*ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
*ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1DirectionalChannelInfoDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_DirectionalChannelInfoDecodeErrorZ* o_conv = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1DirectionalChannelInfoDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_DirectionalChannelInfoDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
+ *ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DirectionalChannelInfoDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_DirectionalChannelInfoDecodeErrorZ* arg_conv = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1DirectionalChannelInfoDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_DirectionalChannelInfoDecodeErrorZ* orig_conv = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(orig & ~1);
LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
LDKChannelInfo o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelInfo_clone(&o_conv);
LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
*ret_conv = CResult_ChannelInfoDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
*ret_conv = CResult_ChannelInfoDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelInfoDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ChannelInfoDecodeErrorZ* o_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelInfoDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelInfoDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelInfoDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
+ *ret_conv = CResult_ChannelInfoDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelInfoDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ChannelInfoDecodeErrorZ* arg_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelInfoDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ChannelInfoDecodeErrorZ* orig_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
LDKRoutingFees o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RoutingFees_clone(&o_conv);
LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
*ret_conv = CResult_RoutingFeesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
*ret_conv = CResult_RoutingFeesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RoutingFeesDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_RoutingFeesDecodeErrorZ* o_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RoutingFeesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RoutingFeesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RoutingFeesDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
+ *ret_conv = CResult_RoutingFeesDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RoutingFeesDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_RoutingFeesDecodeErrorZ* arg_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RoutingFeesDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_RoutingFeesDecodeErrorZ* orig_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(orig & ~1);
LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
LDKNodeAnnouncementInfo o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NodeAnnouncementInfo_clone(&o_conv);
LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
*ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
*ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementInfoDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ* o_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementInfoDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
+ *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementInfoDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ* arg_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementInfoDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NodeAnnouncementInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(orig & ~1);
LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
LDKNodeInfo o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NodeInfo_clone(&o_conv);
LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
*ret_conv = CResult_NodeInfoDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
*ret_conv = CResult_NodeInfoDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NodeInfoDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NodeInfoDecodeErrorZ* o_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeInfoDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeInfoDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NodeInfoDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
+ *ret_conv = CResult_NodeInfoDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeInfoDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NodeInfoDecodeErrorZ* arg_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NodeInfoDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeInfoDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NodeInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(orig & ~1);
LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
LDKNetworkGraph o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NetworkGraph_clone(&o_conv);
LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
*ret_conv = CResult_NetworkGraphDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
*ret_conv = CResult_NetworkGraphDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NetworkGraphDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NetworkGraphDecodeErrorZ* o_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NetworkGraphDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NetworkGraphDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NetworkGraphDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NetworkGraphDecodeErrorZ_clone_ptr(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
+ *ret_conv = CResult_NetworkGraphDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetworkGraphDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NetworkGraphDecodeErrorZ* arg_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NetworkGraphDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetworkGraphDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NetworkGraphDecodeErrorZ* orig_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)(orig & ~1);
LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
COption_CVec_NetAddressZZ_free(_res_conv);
}
+static inline uint64_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg) {
+ LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
+ *ret_copy = COption_CVec_NetAddressZZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1CVec_1NetAddressZZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCOption_CVec_NetAddressZZ* arg_conv = (LDKCOption_CVec_NetAddressZZ*)arg;
+ int64_t ret_val = COption_CVec_NetAddressZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_COption_1CVec_1NetAddressZZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCOption_CVec_NetAddressZZ* orig_conv = (LDKCOption_CVec_NetAddressZZ*)orig;
LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
*ret_conv = CResult_NetAddressDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NetAddressDecodeErrorZ* o_conv = (LDKCResult_NetAddressDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NetAddressDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NetAddressDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
+ *ret_conv = CResult_NetAddressDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NetAddressDecodeErrorZ* arg_conv = (LDKCResult_NetAddressDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NetAddressDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NetAddressDecodeErrorZ* orig_conv = (LDKCResult_NetAddressDecodeErrorZ*)(orig & ~1);
LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
LDKUpdateAddHTLC _res_conv_15_conv;
_res_conv_15_conv.inner = (void*)(_res_conv_15 & (~1));
_res_conv_15_conv.is_owned = (_res_conv_15 & 1) || (_res_conv_15 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_15_conv);
_res_constr.data[p] = _res_conv_15_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
LDKUpdateFulfillHTLC _res_conv_19_conv;
_res_conv_19_conv.inner = (void*)(_res_conv_19 & (~1));
_res_conv_19_conv.is_owned = (_res_conv_19 & 1) || (_res_conv_19 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_19_conv);
_res_constr.data[t] = _res_conv_19_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
LDKUpdateFailHTLC _res_conv_16_conv;
_res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
_res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
_res_constr.data[q] = _res_conv_16_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
LDKUpdateFailMalformedHTLC _res_conv_25_conv;
_res_conv_25_conv.inner = (void*)(_res_conv_25 & (~1));
_res_conv_25_conv.is_owned = (_res_conv_25 & 1) || (_res_conv_25 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_25_conv);
_res_constr.data[z] = _res_conv_25_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
LDKAcceptChannel o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = AcceptChannel_clone(&o_conv);
LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
*ret_conv = CResult_AcceptChannelDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
*ret_conv = CResult_AcceptChannelDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1AcceptChannelDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_AcceptChannelDecodeErrorZ* o_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_AcceptChannelDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1AcceptChannelDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_AcceptChannelDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
+ *ret_conv = CResult_AcceptChannelDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1AcceptChannelDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_AcceptChannelDecodeErrorZ* arg_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1AcceptChannelDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_AcceptChannelDecodeErrorZ* orig_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(orig & ~1);
LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
LDKAnnouncementSignatures o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = AnnouncementSignatures_clone(&o_conv);
LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
*ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
*ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1AnnouncementSignaturesDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ* o_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1AnnouncementSignaturesDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_AnnouncementSignaturesDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
+ *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1AnnouncementSignaturesDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ* arg_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1AnnouncementSignaturesDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_AnnouncementSignaturesDecodeErrorZ* orig_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(orig & ~1);
LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
LDKChannelReestablish o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelReestablish_clone(&o_conv);
LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
*ret_conv = CResult_ChannelReestablishDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
*ret_conv = CResult_ChannelReestablishDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelReestablishDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ChannelReestablishDecodeErrorZ* o_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelReestablishDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelReestablishDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelReestablishDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
+ *ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelReestablishDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ChannelReestablishDecodeErrorZ* arg_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelReestablishDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ChannelReestablishDecodeErrorZ* orig_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
LDKClosingSigned o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ClosingSigned_clone(&o_conv);
LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
*ret_conv = CResult_ClosingSignedDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
*ret_conv = CResult_ClosingSignedDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ClosingSignedDecodeErrorZ* o_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ClosingSignedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ClosingSignedDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
+ *ret_conv = CResult_ClosingSignedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ClosingSignedDecodeErrorZ* arg_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ClosingSignedDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(orig & ~1);
LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
LDKClosingSignedFeeRange o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ClosingSignedFeeRange_clone(&o_conv);
LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
*ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
*ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedFeeRangeDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* o_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedFeeRangeDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
+ *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedFeeRangeDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* arg_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedFeeRangeDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(orig & ~1);
LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
LDKCommitmentSigned o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = CommitmentSigned_clone(&o_conv);
LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
*ret_conv = CResult_CommitmentSignedDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
*ret_conv = CResult_CommitmentSignedDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentSignedDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_CommitmentSignedDecodeErrorZ* o_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CommitmentSignedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentSignedDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CommitmentSignedDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
+ *ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentSignedDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_CommitmentSignedDecodeErrorZ* arg_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentSignedDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_CommitmentSignedDecodeErrorZ* orig_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(orig & ~1);
LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
LDKFundingCreated o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = FundingCreated_clone(&o_conv);
LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
*ret_conv = CResult_FundingCreatedDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
*ret_conv = CResult_FundingCreatedDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1FundingCreatedDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_FundingCreatedDecodeErrorZ* o_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_FundingCreatedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1FundingCreatedDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_FundingCreatedDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
+ *ret_conv = CResult_FundingCreatedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingCreatedDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_FundingCreatedDecodeErrorZ* arg_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingCreatedDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_FundingCreatedDecodeErrorZ* orig_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(orig & ~1);
LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
LDKFundingSigned o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = FundingSigned_clone(&o_conv);
LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
*ret_conv = CResult_FundingSignedDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
*ret_conv = CResult_FundingSignedDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1FundingSignedDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_FundingSignedDecodeErrorZ* o_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_FundingSignedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1FundingSignedDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_FundingSignedDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
+ *ret_conv = CResult_FundingSignedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingSignedDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_FundingSignedDecodeErrorZ* arg_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_FundingSignedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingSignedDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_FundingSignedDecodeErrorZ* orig_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(orig & ~1);
LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
LDKFundingLocked o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = FundingLocked_clone(&o_conv);
LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
*ret_conv = CResult_FundingLockedDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
*ret_conv = CResult_FundingLockedDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1FundingLockedDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_FundingLockedDecodeErrorZ* o_conv = (LDKCResult_FundingLockedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_FundingLockedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1FundingLockedDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_FundingLockedDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_FundingLockedDecodeErrorZ_clone_ptr(LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
+ *ret_conv = CResult_FundingLockedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingLockedDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_FundingLockedDecodeErrorZ* arg_conv = (LDKCResult_FundingLockedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_FundingLockedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1FundingLockedDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_FundingLockedDecodeErrorZ* orig_conv = (LDKCResult_FundingLockedDecodeErrorZ*)(orig & ~1);
LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
LDKInit o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Init_clone(&o_conv);
LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
*ret_conv = CResult_InitDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
*ret_conv = CResult_InitDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1InitDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_InitDecodeErrorZ* o_conv = (LDKCResult_InitDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InitDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InitDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_InitDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
+ *ret_conv = CResult_InitDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InitDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_InitDecodeErrorZ* arg_conv = (LDKCResult_InitDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_InitDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InitDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_InitDecodeErrorZ* orig_conv = (LDKCResult_InitDecodeErrorZ*)(orig & ~1);
LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
LDKOpenChannel o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = OpenChannel_clone(&o_conv);
LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
*ret_conv = CResult_OpenChannelDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
*ret_conv = CResult_OpenChannelDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1OpenChannelDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_OpenChannelDecodeErrorZ* o_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_OpenChannelDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1OpenChannelDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_OpenChannelDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
+ *ret_conv = CResult_OpenChannelDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OpenChannelDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_OpenChannelDecodeErrorZ* arg_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_OpenChannelDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1OpenChannelDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_OpenChannelDecodeErrorZ* orig_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(orig & ~1);
LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
LDKRevokeAndACK o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RevokeAndACK_clone(&o_conv);
LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
*ret_conv = CResult_RevokeAndACKDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
*ret_conv = CResult_RevokeAndACKDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RevokeAndACKDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_RevokeAndACKDecodeErrorZ* o_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RevokeAndACKDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RevokeAndACKDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RevokeAndACKDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
+ *ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RevokeAndACKDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_RevokeAndACKDecodeErrorZ* arg_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1RevokeAndACKDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_RevokeAndACKDecodeErrorZ* orig_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(orig & ~1);
LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
LDKShutdown o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Shutdown_clone(&o_conv);
LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
*ret_conv = CResult_ShutdownDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
*ret_conv = CResult_ShutdownDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ShutdownDecodeErrorZ* o_conv = (LDKCResult_ShutdownDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ShutdownDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ShutdownDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
+ *ret_conv = CResult_ShutdownDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ShutdownDecodeErrorZ* arg_conv = (LDKCResult_ShutdownDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ShutdownDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ShutdownDecodeErrorZ* orig_conv = (LDKCResult_ShutdownDecodeErrorZ*)(orig & ~1);
LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
LDKUpdateFailHTLC o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UpdateFailHTLC_clone(&o_conv);
LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailHTLCDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_UpdateFailHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailHTLCDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UpdateFailHTLCDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailHTLCDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_UpdateFailHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailHTLCDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_UpdateFailHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(orig & ~1);
LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
LDKUpdateFailMalformedHTLC o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UpdateFailMalformedHTLC_clone(&o_conv);
LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailMalformedHTLCDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailMalformedHTLCDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailMalformedHTLCDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailMalformedHTLCDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(orig & ~1);
LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
LDKUpdateFee o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UpdateFee_clone(&o_conv);
LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
*ret_conv = CResult_UpdateFeeDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
*ret_conv = CResult_UpdateFeeDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFeeDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_UpdateFeeDecodeErrorZ* o_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateFeeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFeeDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UpdateFeeDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
+ *ret_conv = CResult_UpdateFeeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFeeDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_UpdateFeeDecodeErrorZ* arg_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFeeDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_UpdateFeeDecodeErrorZ* orig_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(orig & ~1);
LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
LDKUpdateFulfillHTLC o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UpdateFulfillHTLC_clone(&o_conv);
LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFulfillHTLCDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFulfillHTLCDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFulfillHTLCDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFulfillHTLCDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_UpdateFulfillHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(orig & ~1);
LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
LDKUpdateAddHTLC o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UpdateAddHTLC_clone(&o_conv);
LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateAddHTLCDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_UpdateAddHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateAddHTLCDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UpdateAddHTLCDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateAddHTLCDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_UpdateAddHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateAddHTLCDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_UpdateAddHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(orig & ~1);
LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
LDKPing o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Ping_clone(&o_conv);
LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
*ret_conv = CResult_PingDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
*ret_conv = CResult_PingDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PingDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_PingDecodeErrorZ* o_conv = (LDKCResult_PingDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PingDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PingDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PingDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
+ *ret_conv = CResult_PingDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PingDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_PingDecodeErrorZ* arg_conv = (LDKCResult_PingDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PingDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PingDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_PingDecodeErrorZ* orig_conv = (LDKCResult_PingDecodeErrorZ*)(orig & ~1);
LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
LDKPong o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Pong_clone(&o_conv);
LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
*ret_conv = CResult_PongDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
*ret_conv = CResult_PongDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PongDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_PongDecodeErrorZ* o_conv = (LDKCResult_PongDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PongDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PongDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PongDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
+ *ret_conv = CResult_PongDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PongDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_PongDecodeErrorZ* arg_conv = (LDKCResult_PongDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PongDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1PongDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_PongDecodeErrorZ* orig_conv = (LDKCResult_PongDecodeErrorZ*)(orig & ~1);
LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
LDKUnsignedChannelAnnouncement o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UnsignedChannelAnnouncement_clone(&o_conv);
LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
*ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
*ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelAnnouncementDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* o_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelAnnouncementDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelAnnouncementDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelAnnouncementDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(orig & ~1);
LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
LDKChannelAnnouncement o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelAnnouncement_clone(&o_conv);
LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
*ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
*ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelAnnouncementDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ChannelAnnouncementDecodeErrorZ* o_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelAnnouncementDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelAnnouncementDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelAnnouncementDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ChannelAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelAnnouncementDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
LDKUnsignedChannelUpdate o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UnsignedChannelUpdate_clone(&o_conv);
LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
*ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
*ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelUpdateDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ* o_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelUpdateDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
+ *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelUpdateDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ* arg_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelUpdateDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_UnsignedChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(orig & ~1);
LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
LDKChannelUpdate o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelUpdate_clone(&o_conv);
LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
*ret_conv = CResult_ChannelUpdateDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
*ret_conv = CResult_ChannelUpdateDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelUpdateDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ChannelUpdateDecodeErrorZ* o_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelUpdateDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelUpdateDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelUpdateDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
+ *ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelUpdateDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ChannelUpdateDecodeErrorZ* arg_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelUpdateDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
LDKErrorMessage o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ErrorMessage_clone(&o_conv);
LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
*ret_conv = CResult_ErrorMessageDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
*ret_conv = CResult_ErrorMessageDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ErrorMessageDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ErrorMessageDecodeErrorZ* o_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ErrorMessageDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ErrorMessageDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ErrorMessageDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
+ *ret_conv = CResult_ErrorMessageDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ErrorMessageDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ErrorMessageDecodeErrorZ* arg_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ErrorMessageDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ErrorMessageDecodeErrorZ* orig_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(orig & ~1);
LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
LDKUnsignedNodeAnnouncement o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UnsignedNodeAnnouncement_clone(&o_conv);
LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
*ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
*ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedNodeAnnouncementDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* o_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedNodeAnnouncementDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedNodeAnnouncementDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedNodeAnnouncementDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(orig & ~1);
LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
LDKNodeAnnouncement o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NodeAnnouncement_clone(&o_conv);
LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
*ret_conv = CResult_NodeAnnouncementDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
*ret_conv = CResult_NodeAnnouncementDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_NodeAnnouncementDecodeErrorZ* o_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeAnnouncementDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NodeAnnouncementDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_NodeAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_NodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(orig & ~1);
LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
LDKQueryShortChannelIds o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = QueryShortChannelIds_clone(&o_conv);
LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
*ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
*ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1QueryShortChannelIdsDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ* o_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1QueryShortChannelIdsDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_QueryShortChannelIdsDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
+ *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1QueryShortChannelIdsDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ* arg_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1QueryShortChannelIdsDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_QueryShortChannelIdsDecodeErrorZ* orig_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(orig & ~1);
LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
LDKReplyShortChannelIdsEnd o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ReplyShortChannelIdsEnd_clone(&o_conv);
LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
*ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
*ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyShortChannelIdsEndDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* o_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyShortChannelIdsEndDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
+ *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyShortChannelIdsEndDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* arg_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyShortChannelIdsEndDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* orig_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(orig & ~1);
LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
LDKQueryChannelRange o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = QueryChannelRange_clone(&o_conv);
LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
*ret_conv = CResult_QueryChannelRangeDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
*ret_conv = CResult_QueryChannelRangeDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1QueryChannelRangeDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_QueryChannelRangeDecodeErrorZ* o_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_QueryChannelRangeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1QueryChannelRangeDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_QueryChannelRangeDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
+ *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1QueryChannelRangeDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_QueryChannelRangeDecodeErrorZ* arg_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1QueryChannelRangeDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_QueryChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(orig & ~1);
LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
LDKReplyChannelRange o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ReplyChannelRange_clone(&o_conv);
LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
*ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
*ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyChannelRangeDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_ReplyChannelRangeDecodeErrorZ* o_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyChannelRangeDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ReplyChannelRangeDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
+ *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyChannelRangeDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_ReplyChannelRangeDecodeErrorZ* arg_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyChannelRangeDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_ReplyChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(orig & ~1);
LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
LDKGossipTimestampFilter o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = GossipTimestampFilter_clone(&o_conv);
LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
*ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
*ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1GossipTimestampFilterDecodeErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_GossipTimestampFilterDecodeErrorZ* o_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1GossipTimestampFilterDecodeErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_GossipTimestampFilterDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
+ *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1GossipTimestampFilterDecodeErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_GossipTimestampFilterDecodeErrorZ* arg_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1GossipTimestampFilterDecodeErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_GossipTimestampFilterDecodeErrorZ* orig_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(orig & ~1);
LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
LDKInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Invoice_clone(&o_conv);
LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
*ret_conv = CResult_InvoiceSignOrCreationErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSignOrCreationErrorZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_InvoiceSignOrCreationErrorZ* o_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InvoiceSignOrCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSignOrCreationErrorZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_InvoiceSignOrCreationErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
+ *ret_conv = CResult_InvoiceSignOrCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSignOrCreationErrorZ_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCResult_InvoiceSignOrCreationErrorZ* arg_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSignOrCreationErrorZ_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCResult_InvoiceSignOrCreationErrorZ* orig_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)(orig & ~1);
LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
LDKLockedChannelMonitor o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
// Warning: we need a move here but no clone is available for LDKLockedChannelMonitor
LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
*ret_conv = CResult_LockedChannelMonitorNoneZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1LockedChannelMonitorNoneZ_1is_1ok(JNIEnv *env, jclass clz, int64_t o) {
+ LDKCResult_LockedChannelMonitorNoneZ* o_conv = (LDKCResult_LockedChannelMonitorNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_LockedChannelMonitorNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1LockedChannelMonitorNoneZ_1free(JNIEnv *env, jclass clz, int64_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKOutPoint _res_conv_10_conv;
_res_conv_10_conv.inner = (void*)(_res_conv_10 & (~1));
_res_conv_10_conv.is_owned = (_res_conv_10 & 1) || (_res_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_10_conv);
_res_constr.data[k] = _res_conv_10_conv;
}
(*env)->ReleaseLongArrayElements(env, _res, _res_vals, 0);
PaymentPurpose_free(this_ptr_conv);
}
+static inline uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg) {
+ LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
+ *ret_copy = PaymentPurpose_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PaymentPurpose_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKPaymentPurpose* arg_conv = (LDKPaymentPurpose*)arg;
+ int64_t ret_val = PaymentPurpose_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PaymentPurpose_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKPaymentPurpose* orig_conv = (LDKPaymentPurpose*)orig;
LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
ClosureReason_free(this_ptr_conv);
}
+static inline uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg) {
+ LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
+ *ret_copy = ClosureReason_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosureReason_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKClosureReason* arg_conv = (LDKClosureReason*)arg;
+ int64_t ret_val = ClosureReason_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosureReason_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKClosureReason* orig_conv = (LDKClosureReason*)orig;
LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
return ret_arr;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosureReason_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = (*env)->GetArrayLength(env, ser);
+ ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = ClosureReason_read(ser_ref);
+ (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
+ return (uint64_t)ret_conv;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Event_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
if ((this_ptr & 1) != 0) return;
void* this_ptr_ptr = (void*)(((uint64_t)this_ptr) & ~1);
Event_free(this_ptr_conv);
}
+static inline uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg) {
+ LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
+ *ret_copy = Event_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Event_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKEvent* arg_conv = (LDKEvent*)arg;
+ int64_t ret_val = Event_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Event_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKEvent* orig_conv = (LDKEvent*)orig;
LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
LDKRouteHop path_conv_10_conv;
path_conv_10_conv.inner = (void*)(path_conv_10 & (~1));
path_conv_10_conv.is_owned = (path_conv_10 & 1) || (path_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
path_constr.data[k] = path_conv_10_conv;
}
LDKRouteParameters retry_conv;
retry_conv.inner = (void*)(retry & (~1));
retry_conv.is_owned = (retry & 1) || (retry == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(retry_conv);
retry_conv = RouteParameters_clone(&retry_conv);
LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
*ret_copy = Event_payment_path_failed(payment_id_ref, payment_hash_ref, rejected_by_dest, network_update_conv, all_paths_failed, path_constr, short_channel_id_conv, retry_conv);
return ret_arr;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Event_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = (*env)->GetArrayLength(env, ser);
+ ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = Event_read(ser_ref);
+ (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
+ return (uint64_t)ret_conv;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MessageSendEvent_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
if ((this_ptr & 1) != 0) return;
void* this_ptr_ptr = (void*)(((uint64_t)this_ptr) & ~1);
MessageSendEvent_free(this_ptr_conv);
}
+static inline uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg) {
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MessageSendEvent_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKMessageSendEvent* arg_conv = (LDKMessageSendEvent*)arg;
+ int64_t ret_val = MessageSendEvent_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MessageSendEvent_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKMessageSendEvent* orig_conv = (LDKMessageSendEvent*)orig;
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
LDKAcceptChannel msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = AcceptChannel_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_accept_channel(node_id_ref, msg_conv);
LDKOpenChannel msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = OpenChannel_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_open_channel(node_id_ref, msg_conv);
LDKFundingCreated msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = FundingCreated_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_funding_created(node_id_ref, msg_conv);
LDKFundingSigned msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = FundingSigned_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_funding_signed(node_id_ref, msg_conv);
LDKFundingLocked msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = FundingLocked_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_funding_locked(node_id_ref, msg_conv);
LDKAnnouncementSignatures msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = AnnouncementSignatures_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_announcement_signatures(node_id_ref, msg_conv);
LDKCommitmentUpdate updates_conv;
updates_conv.inner = (void*)(updates & (~1));
updates_conv.is_owned = (updates & 1) || (updates == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_conv);
updates_conv = CommitmentUpdate_clone(&updates_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_update_htlcs(node_id_ref, updates_conv);
LDKRevokeAndACK msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = RevokeAndACK_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_revoke_and_ack(node_id_ref, msg_conv);
LDKClosingSigned msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ClosingSigned_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_closing_signed(node_id_ref, msg_conv);
LDKShutdown msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = Shutdown_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_shutdown(node_id_ref, msg_conv);
LDKChannelReestablish msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ChannelReestablish_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_channel_reestablish(node_id_ref, msg_conv);
LDKChannelAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ChannelAnnouncement_clone(&msg_conv);
LDKChannelUpdate update_msg_conv;
update_msg_conv.inner = (void*)(update_msg & (~1));
update_msg_conv.is_owned = (update_msg & 1) || (update_msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_conv);
update_msg_conv = ChannelUpdate_clone(&update_msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_broadcast_channel_announcement(msg_conv, update_msg_conv);
LDKNodeAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = NodeAnnouncement_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_broadcast_node_announcement(msg_conv);
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ChannelUpdate_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_broadcast_channel_update(msg_conv);
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ChannelUpdate_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_channel_update(node_id_ref, msg_conv);
LDKQueryChannelRange msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = QueryChannelRange_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_channel_range_query(node_id_ref, msg_conv);
LDKQueryShortChannelIds msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = QueryShortChannelIds_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_short_ids_query(node_id_ref, msg_conv);
LDKReplyChannelRange msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ReplyChannelRange_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_reply_channel_range(node_id_ref, msg_conv);
APIError_free(this_ptr_conv);
}
+static inline uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg) {
+ LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
+ *ret_copy = APIError_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_APIError_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKAPIError* arg_conv = (LDKAPIError*)arg;
+ int64_t ret_val = APIError_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_APIError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKAPIError* orig_conv = (LDKAPIError*)orig;
LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
LDKShutdownScript script_conv;
script_conv.inner = (void*)(script & (~1));
script_conv.is_owned = (script & 1) || (script == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(script_conv);
script_conv = ShutdownScript_clone(&script_conv);
LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
*ret_copy = APIError_incompatible_shutdown_script(script_conv);
return ret_conv;
}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Record_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
+ LDKRecord this_obj_conv;
+ this_obj_conv.inner = (void*)(this_obj & (~1));
+ this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
+ Record_free(this_obj_conv);
+}
+
+JNIEXPORT jclass JNICALL Java_org_ldk_impl_bindings_Record_1get_1level(JNIEnv *env, jclass clz, int64_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ jclass ret_conv = LDKLevel_to_java(env, Record_get_level(&this_ptr_conv));
+ return ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Record_1set_1level(JNIEnv *env, jclass clz, int64_t this_ptr, jclass val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKLevel val_conv = LDKLevel_from_java(env, val);
+ Record_set_level(&this_ptr_conv, val_conv);
+}
+
+JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_Record_1get_1args(JNIEnv *env, jclass clz, int64_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr ret_str = Record_get_args(&this_ptr_conv);
+ jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
+ Str_free(ret_str);
+ return ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Record_1set_1args(JNIEnv *env, jclass clz, int64_t this_ptr, jstring val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr val_conv = java_to_owned_str(env, val);
+ Record_set_args(&this_ptr_conv, val_conv);
+}
+
+JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_Record_1get_1module_1path(JNIEnv *env, jclass clz, int64_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr ret_str = Record_get_module_path(&this_ptr_conv);
+ jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
+ Str_free(ret_str);
+ return ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Record_1set_1module_1path(JNIEnv *env, jclass clz, int64_t this_ptr, jstring val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr val_conv = java_to_owned_str(env, val);
+ Record_set_module_path(&this_ptr_conv, val_conv);
+}
+
+JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_Record_1get_1file(JNIEnv *env, jclass clz, int64_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr ret_str = Record_get_file(&this_ptr_conv);
+ jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
+ Str_free(ret_str);
+ return ret_conv;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Record_1set_1file(JNIEnv *env, jclass clz, int64_t this_ptr, jstring val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr val_conv = java_to_owned_str(env, val);
+ Record_set_file(&this_ptr_conv, val_conv);
+}
+
+JNIEXPORT int32_t JNICALL Java_org_ldk_impl_bindings_Record_1get_1line(JNIEnv *env, jclass clz, int64_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ int32_t ret_val = Record_get_line(&this_ptr_conv);
+ return ret_val;
+}
+
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Record_1set_1line(JNIEnv *env, jclass clz, int64_t this_ptr, int32_t val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ Record_set_line(&this_ptr_conv, val);
+}
+
+static inline uint64_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg) {
+ LDKRecord ret_var = Record_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Record_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKRecord arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Record_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Record_1clone(JNIEnv *env, jclass clz, int64_t orig) {
+ LDKRecord orig_conv;
+ orig_conv.inner = (void*)(orig & (~1));
+ orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
+ LDKRecord ret_var = Record_clone(&orig_conv);
+ uint64_t ret_ref = 0;
+ CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = (uint64_t)ret_var.inner;
+ if (ret_var.is_owned) {
+ ret_ref |= 1;
+ }
+ return ret_ref;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Logger_1free(JNIEnv *env, jclass clz, int64_t this_ptr) {
if ((this_ptr & 1) != 0) return;
void* this_ptr_ptr = (void*)(((uint64_t)this_ptr) & ~1);
LDKChannelHandshakeConfig this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelHandshakeConfig_free(this_obj_conv);
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ChannelHandshakeConfig_get_minimum_depth(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeConfig_set_minimum_depth(&this_ptr_conv, val);
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = ChannelHandshakeConfig_get_our_to_self_delay(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeConfig_set_our_to_self_delay(&this_ptr_conv, val);
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelHandshakeConfig_get_our_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeConfig_set_our_htlc_minimum_msat(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg) {
+ LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelHandshakeConfig arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelHandshakeConfig_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelHandshakeConfig orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelHandshakeLimits this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelHandshakeLimits_free(this_obj_conv);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelHandshakeLimits_get_min_funding_satoshis(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_min_funding_satoshis(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelHandshakeLimits_get_max_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_max_htlc_minimum_msat(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelHandshakeLimits_get_max_channel_reserve_satoshis(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_max_channel_reserve_satoshis(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = ChannelHandshakeLimits_get_min_max_accepted_htlcs(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_min_max_accepted_htlcs(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ChannelHandshakeLimits_get_max_minimum_depth(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_max_minimum_depth(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelHandshakeLimits_get_force_announced_channel_preference(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_force_announced_channel_preference(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = ChannelHandshakeLimits_get_their_to_self_delay(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_their_to_self_delay(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg) {
+ LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelHandshakeLimits arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelHandshakeLimits_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelHandshakeLimits orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelConfig this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelConfig_free(this_obj_conv);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ChannelConfig_get_forwarding_fee_proportional_millionths(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_forwarding_fee_proportional_millionths(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ChannelConfig_get_forwarding_fee_base_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_forwarding_fee_base_msat(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = ChannelConfig_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelConfig_get_announced_channel(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_announced_channel(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelConfig_get_commit_upfront_shutdown_pubkey(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_commit_upfront_shutdown_pubkey(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelConfig_get_max_dust_htlc_exposure_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_max_dust_htlc_exposure_msat(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelConfig_get_force_close_avoidance_max_fee_satoshis(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_force_close_avoidance_max_fee_satoshis(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg) {
+ LDKChannelConfig ret_var = ChannelConfig_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelConfig arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelConfig_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelConfig orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelConfig ret_var = ChannelConfig_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelConfig obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelConfig_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKUserConfig this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UserConfig_free(this_obj_conv);
}
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelHandshakeConfig ret_var = UserConfig_get_own_channel_config(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelHandshakeConfig val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelHandshakeConfig_clone(&val_conv);
UserConfig_set_own_channel_config(&this_ptr_conv, val_conv);
}
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelHandshakeLimits ret_var = UserConfig_get_peer_channel_config_limits(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelHandshakeLimits val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelHandshakeLimits_clone(&val_conv);
UserConfig_set_peer_channel_config_limits(&this_ptr_conv, val_conv);
}
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelConfig ret_var = UserConfig_get_channel_options(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelConfig val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelConfig_clone(&val_conv);
UserConfig_set_channel_options(&this_ptr_conv, val_conv);
}
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = UserConfig_get_accept_forwards_to_priv_channels(&this_ptr_conv);
return ret_val;
}
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UserConfig_set_accept_forwards_to_priv_channels(&this_ptr_conv, val);
}
LDKChannelHandshakeConfig own_channel_config_arg_conv;
own_channel_config_arg_conv.inner = (void*)(own_channel_config_arg & (~1));
own_channel_config_arg_conv.is_owned = (own_channel_config_arg & 1) || (own_channel_config_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(own_channel_config_arg_conv);
own_channel_config_arg_conv = ChannelHandshakeConfig_clone(&own_channel_config_arg_conv);
LDKChannelHandshakeLimits peer_channel_config_limits_arg_conv;
peer_channel_config_limits_arg_conv.inner = (void*)(peer_channel_config_limits_arg & (~1));
peer_channel_config_limits_arg_conv.is_owned = (peer_channel_config_limits_arg & 1) || (peer_channel_config_limits_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(peer_channel_config_limits_arg_conv);
peer_channel_config_limits_arg_conv = ChannelHandshakeLimits_clone(&peer_channel_config_limits_arg_conv);
LDKChannelConfig channel_options_arg_conv;
channel_options_arg_conv.inner = (void*)(channel_options_arg & (~1));
channel_options_arg_conv.is_owned = (channel_options_arg & 1) || (channel_options_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_options_arg_conv);
channel_options_arg_conv = ChannelConfig_clone(&channel_options_arg_conv);
LDKUserConfig ret_var = UserConfig_new(own_channel_config_arg_conv, peer_channel_config_limits_arg_conv, channel_options_arg_conv, accept_forwards_to_priv_channels_arg);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg) {
+ LDKUserConfig ret_var = UserConfig_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UserConfig_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKUserConfig arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UserConfig_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UserConfig_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKUserConfig orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUserConfig ret_var = UserConfig_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKBestBlock this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
BestBlock_free(this_obj_conv);
}
+static inline uint64_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg) {
+ LDKBestBlock ret_var = BestBlock_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BestBlock_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKBestBlock arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = BestBlock_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BestBlock_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKBestBlock orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKBestBlock ret_var = BestBlock_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKBestBlock this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, BestBlock_block_hash(&this_arg_conv).data);
return ret_arr;
LDKBestBlock this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int32_t ret_val = BestBlock_height(&this_arg_conv);
return ret_val;
}
LDKWatchedOutput this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
WatchedOutput_free(this_obj_conv);
}
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, WatchedOutput_get_block_hash(&this_ptr_conv).data);
return ret_arr;
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint ret_var = WatchedOutput_get_outpoint(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = OutPoint_clone(&val_conv);
WatchedOutput_set_outpoint(&this_ptr_conv, val_conv);
}
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKu8slice ret_var = WatchedOutput_get_script_pubkey(&this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u8Z val_ref;
val_ref.datalen = (*env)->GetArrayLength(env, val);
val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
LDKOutPoint outpoint_arg_conv;
outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
LDKCVec_u8Z script_pubkey_arg_ref;
script_pubkey_arg_ref.datalen = (*env)->GetArrayLength(env, script_pubkey_arg);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg) {
+ LDKWatchedOutput ret_var = WatchedOutput_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_WatchedOutput_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKWatchedOutput arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = WatchedOutput_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_WatchedOutput_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKWatchedOutput orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKWatchedOutput ret_var = WatchedOutput_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKWatchedOutput o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = WatchedOutput_hash(&o_conv);
return ret_val;
}
LDKMonitorUpdateId this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
MonitorUpdateId_free(this_obj_conv);
}
+static inline uint64_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg) {
+ LDKMonitorUpdateId ret_var = MonitorUpdateId_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MonitorUpdateId_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKMonitorUpdateId arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = MonitorUpdateId_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MonitorUpdateId_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKMonitorUpdateId orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKMonitorUpdateId ret_var = MonitorUpdateId_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKMonitorUpdateId o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = MonitorUpdateId_hash(&o_conv);
return ret_val;
}
LDKMonitorUpdateId a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKMonitorUpdateId b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = MonitorUpdateId_eq(&a_conv, &b_conv);
return ret_val;
}
LDKLockedChannelMonitor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
LockedChannelMonitor_free(this_obj_conv);
}
LDKChainMonitor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChainMonitor_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_ChannelDetailsZ ignored_channels_constr;
ignored_channels_constr.datalen = (*env)->GetArrayLength(env, ignored_channels);
if (ignored_channels_constr.datalen > 0)
LDKChannelDetails ignored_channels_conv_16_conv;
ignored_channels_conv_16_conv.inner = (void*)(ignored_channels_conv_16 & (~1));
ignored_channels_conv_16_conv.is_owned = (ignored_channels_conv_16 & 1) || (ignored_channels_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ignored_channels_conv_16_conv);
ignored_channels_conv_16_conv = ChannelDetails_clone(&ignored_channels_conv_16_conv);
ignored_channels_constr.data[q] = ignored_channels_conv_16_conv;
}
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKOutPoint funding_txo_conv;
funding_txo_conv.inner = (void*)(funding_txo & (~1));
funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
funding_txo_conv = OutPoint_clone(&funding_txo_conv);
LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
*ret_conv = ChainMonitor_get_monitor(&this_arg_conv, funding_txo_conv);
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_OutPointZ ret_var = ChainMonitor_list_monitors(&this_arg_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_10_ref = 0;
CHECK((((uint64_t)ret_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_10_var);
ret_conv_10_ref = (uint64_t)ret_conv_10_var.inner;
if (ret_conv_10_var.is_owned) {
ret_conv_10_ref |= 1;
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKOutPoint funding_txo_conv;
funding_txo_conv.inner = (void*)(funding_txo & (~1));
funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
funding_txo_conv = OutPoint_clone(&funding_txo_conv);
LDKMonitorUpdateId completed_update_id_conv;
completed_update_id_conv.inner = (void*)(completed_update_id & (~1));
completed_update_id_conv.is_owned = (completed_update_id & 1) || (completed_update_id == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(completed_update_id_conv);
completed_update_id_conv = MonitorUpdateId_clone(&completed_update_id_conv);
LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
*ret_conv = ChainMonitor_channel_monitor_updated(&this_arg_conv, funding_txo_conv, completed_update_id_conv);
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKListen* ret_ret = MALLOC(sizeof(LDKListen), "LDKListen");
*ret_ret = ChainMonitor_as_Listen(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKConfirm* ret_ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
*ret_ret = ChainMonitor_as_Confirm(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKWatch* ret_ret = MALLOC(sizeof(LDKWatch), "LDKWatch");
*ret_ret = ChainMonitor_as_Watch(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKEventsProvider* ret_ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
*ret_ret = ChainMonitor_as_EventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelMonitorUpdate this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelMonitorUpdate_free(this_obj_conv);
}
LDKChannelMonitorUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelMonitorUpdate_get_update_id(&this_ptr_conv);
return ret_val;
}
LDKChannelMonitorUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelMonitorUpdate_set_update_id(&this_ptr_conv, val);
}
+static inline uint64_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg) {
+ LDKChannelMonitorUpdate ret_var = ChannelMonitorUpdate_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMonitorUpdate_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelMonitorUpdate arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelMonitorUpdate_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMonitorUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelMonitorUpdate orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelMonitorUpdate ret_var = ChannelMonitorUpdate_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelMonitorUpdate obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelMonitorUpdate_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKMonitorUpdateError this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
MonitorUpdateError_free(this_obj_conv);
}
LDKMonitorUpdateError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr ret_str = MonitorUpdateError_get_a(&this_ptr_conv);
jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
Str_free(ret_str);
LDKMonitorUpdateError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr val_conv = java_to_owned_str(env, val);
MonitorUpdateError_set_a(&this_ptr_conv, val_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t MonitorUpdateError_clone_ptr(LDKMonitorUpdateError *NONNULL_PTR arg) {
+ LDKMonitorUpdateError ret_var = MonitorUpdateError_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MonitorUpdateError_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKMonitorUpdateError arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = MonitorUpdateError_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MonitorUpdateError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKMonitorUpdateError orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKMonitorUpdateError ret_var = MonitorUpdateError_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
MonitorEvent_free(this_ptr_conv);
}
+static inline uint64_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg) {
+ LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
+ *ret_copy = MonitorEvent_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MonitorEvent_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKMonitorEvent* arg_conv = (LDKMonitorEvent*)arg;
+ int64_t ret_val = MonitorEvent_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MonitorEvent_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKMonitorEvent* orig_conv = (LDKMonitorEvent*)orig;
LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
LDKHTLCUpdate a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = HTLCUpdate_clone(&a_conv);
LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
*ret_copy = MonitorEvent_htlcevent(a_conv);
LDKOutPoint a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = OutPoint_clone(&a_conv);
LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
*ret_copy = MonitorEvent_commitment_tx_confirmed(a_conv);
LDKOutPoint funding_txo_conv;
funding_txo_conv.inner = (void*)(funding_txo & (~1));
funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
funding_txo_conv = OutPoint_clone(&funding_txo_conv);
LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
*ret_copy = MonitorEvent_update_completed(funding_txo_conv, monitor_update_id);
LDKOutPoint a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = OutPoint_clone(&a_conv);
LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
*ret_copy = MonitorEvent_update_failed(a_conv);
return ret_arr;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MonitorEvent_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = (*env)->GetArrayLength(env, ser);
+ ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = MonitorEvent_read(ser_ref);
+ (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
+ return (uint64_t)ret_conv;
+}
+
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HTLCUpdate_1free(JNIEnv *env, jclass clz, int64_t this_obj) {
LDKHTLCUpdate this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
HTLCUpdate_free(this_obj_conv);
}
+static inline uint64_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg) {
+ LDKHTLCUpdate ret_var = HTLCUpdate_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HTLCUpdate_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKHTLCUpdate arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = HTLCUpdate_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HTLCUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKHTLCUpdate orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKHTLCUpdate ret_var = HTLCUpdate_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKHTLCUpdate obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = HTLCUpdate_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
Balance_free(this_ptr_conv);
}
+static inline uint64_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg) {
+ LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
+ *ret_copy = Balance_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Balance_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKBalance* arg_conv = (LDKBalance*)arg;
+ int64_t ret_val = Balance_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Balance_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKBalance* orig_conv = (LDKBalance*)orig;
LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
LDKChannelMonitor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelMonitor_free(this_obj_conv);
}
+static inline uint64_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg) {
+ LDKChannelMonitor ret_var = ChannelMonitor_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelMonitor arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelMonitor_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelMonitor orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelMonitor ret_var = ChannelMonitor_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelMonitor obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelMonitor_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelMonitorUpdate updates_conv;
updates_conv.inner = (void*)(updates & (~1));
updates_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_conv);
void* broadcaster_ptr = (void*)(((uint64_t)broadcaster) & ~1);
if (!(broadcaster & 1)) { CHECK_ACCESS(broadcaster_ptr); }
LDKBroadcasterInterface* broadcaster_conv = (LDKBroadcasterInterface*)broadcaster_ptr;
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = ChannelMonitor_get_latest_update_id(&this_arg_conv);
return ret_val;
}
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
*ret_conv = ChannelMonitor_get_funding_txo(&this_arg_conv);
return ((uint64_t)ret_conv);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ret_var = ChannelMonitor_get_outputs_to_watch(&this_arg_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* filter_ptr = (void*)(((uint64_t)filter) & ~1);
if (!(filter & 1)) { CHECK_ACCESS(filter_ptr); }
LDKFilter* filter_conv = (LDKFilter*)filter_ptr;
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_MonitorEventZ ret_var = ChannelMonitor_get_and_clear_pending_monitor_events(&this_arg_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_EventZ ret_var = ChannelMonitor_get_and_clear_pending_events(&this_arg_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* logger_ptr = (void*)(((uint64_t)logger) & ~1);
if (!(logger & 1)) { CHECK_ACCESS(logger_ptr); }
LDKLogger* logger_conv = (LDKLogger*)logger_ptr;
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char header_arr[80];
CHECK((*env)->GetArrayLength(env, header) == 80);
(*env)->GetByteArrayRegion(env, header, 0, 80, header_arr);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char header_arr[80];
CHECK((*env)->GetArrayLength(env, header) == 80);
(*env)->GetByteArrayRegion(env, header, 0, 80, header_arr);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char header_arr[80];
CHECK((*env)->GetArrayLength(env, header) == 80);
(*env)->GetByteArrayRegion(env, header, 0, 80, header_arr);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char txid_arr[32];
CHECK((*env)->GetArrayLength(env, txid) == 32);
(*env)->GetByteArrayRegion(env, txid, 0, 32, txid_arr);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char header_arr[80];
CHECK((*env)->GetArrayLength(env, header) == 80);
(*env)->GetByteArrayRegion(env, header, 0, 80, header_arr);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_TxidZ ret_var = ChannelMonitor_get_relevant_txids(&this_arg_conv);
jobjectArray ret_arr = NULL;
ret_arr = (*env)->NewObjectArray(env, ret_var.datalen, arr_of_B_clz, NULL);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKBestBlock ret_var = ChannelMonitor_current_best_block(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_BalanceZ ret_var = ChannelMonitor_get_claimable_balances(&this_arg_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
LDKOutPoint this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
OutPoint_free(this_obj_conv);
}
LDKOutPoint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *OutPoint_get_txid(&this_ptr_conv));
return ret_arr;
LDKOutPoint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKOutPoint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = OutPoint_get_index(&this_ptr_conv);
return ret_val;
}
LDKOutPoint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OutPoint_set_index(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg) {
+ LDKOutPoint ret_var = OutPoint_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OutPoint_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKOutPoint arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = OutPoint_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OutPoint_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKOutPoint orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKOutPoint ret_var = OutPoint_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKOutPoint a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKOutPoint b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = OutPoint_eq(&a_conv, &b_conv);
return ret_val;
}
LDKOutPoint o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = OutPoint_hash(&o_conv);
return ret_val;
}
LDKOutPoint this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, OutPoint_to_channel_id(&this_arg_conv).data);
return ret_arr;
LDKOutPoint obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = OutPoint_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKDelayedPaymentOutputDescriptor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DelayedPaymentOutputDescriptor_free(this_obj_conv);
}
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint ret_var = DelayedPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = OutPoint_clone(&val_conv);
DelayedPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
}
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, DelayedPaymentOutputDescriptor_get_per_commitment_point(&this_ptr_conv).compressed_form);
return ret_arr;
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = DelayedPaymentOutputDescriptor_get_to_self_delay(&this_ptr_conv);
return ret_val;
}
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DelayedPaymentOutputDescriptor_set_to_self_delay(&this_ptr_conv, val);
}
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKTxOut val_conv = *(LDKTxOut*)(val_ptr);
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, DelayedPaymentOutputDescriptor_get_revocation_pubkey(&this_ptr_conv).compressed_form);
return ret_arr;
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *DelayedPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv));
return ret_arr;
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = DelayedPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
return ret_val;
}
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DelayedPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
}
LDKOutPoint outpoint_arg_conv;
outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
LDKPublicKey per_commitment_point_arg_ref;
CHECK((*env)->GetArrayLength(env, per_commitment_point_arg) == 33);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg) {
+ LDKDelayedPaymentOutputDescriptor ret_var = DelayedPaymentOutputDescriptor_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKDelayedPaymentOutputDescriptor arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = DelayedPaymentOutputDescriptor_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKDelayedPaymentOutputDescriptor orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKDelayedPaymentOutputDescriptor ret_var = DelayedPaymentOutputDescriptor_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDelayedPaymentOutputDescriptor obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = DelayedPaymentOutputDescriptor_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKStaticPaymentOutputDescriptor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
StaticPaymentOutputDescriptor_free(this_obj_conv);
}
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint ret_var = StaticPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = OutPoint_clone(&val_conv);
StaticPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
}
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKTxOut val_conv = *(LDKTxOut*)(val_ptr);
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *StaticPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv));
return ret_arr;
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = StaticPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
return ret_val;
}
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
StaticPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
}
LDKOutPoint outpoint_arg_conv;
outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
void* output_arg_ptr = (void*)(((uint64_t)output_arg) & ~1);
CHECK_ACCESS(output_arg_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg) {
+ LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKStaticPaymentOutputDescriptor arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = StaticPaymentOutputDescriptor_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKStaticPaymentOutputDescriptor orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKStaticPaymentOutputDescriptor obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = StaticPaymentOutputDescriptor_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
SpendableOutputDescriptor_free(this_ptr_conv);
}
+static inline uint64_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg) {
+ LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
+ *ret_copy = SpendableOutputDescriptor_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SpendableOutputDescriptor_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKSpendableOutputDescriptor* arg_conv = (LDKSpendableOutputDescriptor*)arg;
+ int64_t ret_val = SpendableOutputDescriptor_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SpendableOutputDescriptor_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKSpendableOutputDescriptor* orig_conv = (LDKSpendableOutputDescriptor*)orig;
LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
LDKOutPoint outpoint_conv;
outpoint_conv.inner = (void*)(outpoint & (~1));
outpoint_conv.is_owned = (outpoint & 1) || (outpoint == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_conv);
outpoint_conv = OutPoint_clone(&outpoint_conv);
void* output_ptr = (void*)(((uint64_t)output) & ~1);
CHECK_ACCESS(output_ptr);
LDKDelayedPaymentOutputDescriptor a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = DelayedPaymentOutputDescriptor_clone(&a_conv);
LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
*ret_copy = SpendableOutputDescriptor_delayed_payment_output(a_conv);
LDKStaticPaymentOutputDescriptor a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = StaticPaymentOutputDescriptor_clone(&a_conv);
LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
*ret_copy = SpendableOutputDescriptor_static_payment_output(a_conv);
BaseSign_free(this_ptr_conv);
}
+static inline uint64_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg) {
+ LDKSign* ret_ret = MALLOC(sizeof(LDKSign), "LDKSign");
+ *ret_ret = Sign_clone(arg);
+ return (uint64_t)ret_ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Sign_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ void* arg_ptr = (void*)(((uint64_t)arg) & ~1);
+ if (!(arg & 1)) { CHECK_ACCESS(arg_ptr); }
+ LDKSign* arg_conv = (LDKSign*)arg_ptr;
+ int64_t ret_val = Sign_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Sign_1clone(JNIEnv *env, jclass clz, int64_t orig) {
void* orig_ptr = (void*)(((uint64_t)orig) & ~1);
if (!(orig & 1)) { CHECK_ACCESS(orig_ptr); }
LDKInMemorySigner this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InMemorySigner_free(this_obj_conv);
}
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_funding_key(&this_ptr_conv));
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSecretKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.bytes);
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_revocation_base_key(&this_ptr_conv));
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSecretKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.bytes);
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_payment_key(&this_ptr_conv));
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSecretKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.bytes);
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_delayed_payment_base_key(&this_ptr_conv));
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSecretKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.bytes);
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_htlc_base_key(&this_ptr_conv));
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSecretKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.bytes);
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *InMemorySigner_get_commitment_seed(&this_ptr_conv));
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
InMemorySigner_set_commitment_seed(&this_ptr_conv, val_ref);
}
+static inline uint64_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg) {
+ LDKInMemorySigner ret_var = InMemorySigner_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKInMemorySigner arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = InMemorySigner_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKInMemorySigner orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInMemorySigner ret_var = InMemorySigner_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelPublicKeys ret_var = InMemorySigner_counterparty_pubkeys(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int16_t ret_val = InMemorySigner_counterparty_selected_contest_delay(&this_arg_conv);
return ret_val;
}
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int16_t ret_val = InMemorySigner_holder_selected_contest_delay(&this_arg_conv);
return ret_val;
}
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = InMemorySigner_is_outbound(&this_arg_conv);
return ret_val;
}
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKOutPoint ret_var = InMemorySigner_funding_outpoint(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelTransactionParameters ret_var = InMemorySigner_get_channel_parameters(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTransaction spend_tx_ref;
spend_tx_ref.datalen = (*env)->GetArrayLength(env, spend_tx);
spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
LDKStaticPaymentOutputDescriptor descriptor_conv;
descriptor_conv.inner = (void*)(descriptor & (~1));
descriptor_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(descriptor_conv);
LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
*ret_conv = InMemorySigner_sign_counterparty_payment_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
return (uint64_t)ret_conv;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTransaction spend_tx_ref;
spend_tx_ref.datalen = (*env)->GetArrayLength(env, spend_tx);
spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
LDKDelayedPaymentOutputDescriptor descriptor_conv;
descriptor_conv.inner = (void*)(descriptor & (~1));
descriptor_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(descriptor_conv);
LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
*ret_conv = InMemorySigner_sign_dynamic_p2wsh_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
return (uint64_t)ret_conv;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKBaseSign* ret_ret = MALLOC(sizeof(LDKBaseSign), "LDKBaseSign");
*ret_ret = InMemorySigner_as_BaseSign(&this_arg_conv);
return (uint64_t)ret_ret;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKSign* ret_ret = MALLOC(sizeof(LDKSign), "LDKSign");
*ret_ret = InMemorySigner_as_Sign(&this_arg_conv);
return (uint64_t)ret_ret;
LDKInMemorySigner obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = InMemorySigner_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKKeysManager this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
KeysManager_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKKeysManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char params_arr[32];
CHECK((*env)->GetArrayLength(env, params) == 32);
(*env)->GetByteArrayRegion(env, params, 0, 32, params_arr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKKeysManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_SpendableOutputDescriptorZ descriptors_constr;
descriptors_constr.datalen = (*env)->GetArrayLength(env, descriptors);
if (descriptors_constr.datalen > 0)
LDKKeysManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKKeysInterface* ret_ret = MALLOC(sizeof(LDKKeysInterface), "LDKKeysInterface");
*ret_ret = KeysManager_as_KeysInterface(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelManager_free(this_obj_conv);
}
LDKChainParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChainParameters_free(this_obj_conv);
}
LDKChainParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jclass ret_conv = LDKNetwork_to_java(env, ChainParameters_get_network(&this_ptr_conv));
return ret_conv;
}
LDKChainParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNetwork val_conv = LDKNetwork_from_java(env, val);
ChainParameters_set_network(&this_ptr_conv, val_conv);
}
LDKChainParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKBestBlock ret_var = ChainParameters_get_best_block(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChainParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKBestBlock val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = BestBlock_clone(&val_conv);
ChainParameters_set_best_block(&this_ptr_conv, val_conv);
}
LDKBestBlock best_block_arg_conv;
best_block_arg_conv.inner = (void*)(best_block_arg & (~1));
best_block_arg_conv.is_owned = (best_block_arg & 1) || (best_block_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(best_block_arg_conv);
best_block_arg_conv = BestBlock_clone(&best_block_arg_conv);
LDKChainParameters ret_var = ChainParameters_new(network_arg_conv, best_block_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg) {
+ LDKChainParameters ret_var = ChainParameters_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChainParameters_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChainParameters arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChainParameters_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChainParameters_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChainParameters orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChainParameters ret_var = ChainParameters_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCounterpartyForwardingInfo this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
CounterpartyForwardingInfo_free(this_obj_conv);
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = CounterpartyForwardingInfo_get_fee_base_msat(&this_ptr_conv);
return ret_val;
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
CounterpartyForwardingInfo_set_fee_base_msat(&this_ptr_conv, val);
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = CounterpartyForwardingInfo_get_fee_proportional_millionths(&this_ptr_conv);
return ret_val;
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
CounterpartyForwardingInfo_set_fee_proportional_millionths(&this_ptr_conv, val);
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = CounterpartyForwardingInfo_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
CounterpartyForwardingInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg) {
+ LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CounterpartyForwardingInfo_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCounterpartyForwardingInfo arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = CounterpartyForwardingInfo_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CounterpartyForwardingInfo_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCounterpartyForwardingInfo orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelCounterparty this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelCounterparty_free(this_obj_conv);
}
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelCounterparty_get_node_id(&this_ptr_conv).compressed_form);
return ret_arr;
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInitFeatures ret_var = ChannelCounterparty_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInitFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = InitFeatures_clone(&val_conv);
ChannelCounterparty_set_features(&this_ptr_conv, val_conv);
}
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelCounterparty_get_unspendable_punishment_reserve(&this_ptr_conv);
return ret_val;
}
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelCounterparty_set_unspendable_punishment_reserve(&this_ptr_conv, val);
}
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCounterpartyForwardingInfo ret_var = ChannelCounterparty_get_forwarding_info(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCounterpartyForwardingInfo val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = CounterpartyForwardingInfo_clone(&val_conv);
ChannelCounterparty_set_forwarding_info(&this_ptr_conv, val_conv);
}
LDKInitFeatures features_arg_conv;
features_arg_conv.inner = (void*)(features_arg & (~1));
features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
features_arg_conv = InitFeatures_clone(&features_arg_conv);
LDKCounterpartyForwardingInfo forwarding_info_arg_conv;
forwarding_info_arg_conv.inner = (void*)(forwarding_info_arg & (~1));
forwarding_info_arg_conv.is_owned = (forwarding_info_arg & 1) || (forwarding_info_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(forwarding_info_arg_conv);
forwarding_info_arg_conv = CounterpartyForwardingInfo_clone(&forwarding_info_arg_conv);
LDKChannelCounterparty ret_var = ChannelCounterparty_new(node_id_arg_ref, features_arg_conv, unspendable_punishment_reserve_arg, forwarding_info_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg) {
+ LDKChannelCounterparty ret_var = ChannelCounterparty_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelCounterparty_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelCounterparty arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelCounterparty_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelCounterparty_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelCounterparty orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelCounterparty ret_var = ChannelCounterparty_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelDetails this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelDetails_free(this_obj_conv);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ChannelDetails_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelCounterparty ret_var = ChannelDetails_get_counterparty(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelCounterparty val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelCounterparty_clone(&val_conv);
ChannelDetails_set_counterparty(&this_ptr_conv, val_conv);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint ret_var = ChannelDetails_get_funding_txo(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = OutPoint_clone(&val_conv);
ChannelDetails_set_funding_txo(&this_ptr_conv, val_conv);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = ChannelDetails_get_short_channel_id(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelDetails_get_channel_value_satoshis(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_channel_value_satoshis(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = ChannelDetails_get_unspendable_punishment_reserve(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelDetails_get_user_channel_id(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_user_channel_id(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelDetails_get_outbound_capacity_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_outbound_capacity_msat(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelDetails_get_inbound_capacity_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_inbound_capacity_msat(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
*ret_copy = ChannelDetails_get_confirmations_required(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
*ret_copy = ChannelDetails_get_force_close_spend_delay(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u16Z val_conv = *(LDKCOption_u16Z*)(val_ptr);
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelDetails_get_is_outbound(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_is_outbound(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelDetails_get_is_funding_locked(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_is_funding_locked(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelDetails_get_is_usable(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_is_usable(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelDetails_get_is_public(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_is_public(&this_ptr_conv, val);
}
LDKChannelCounterparty counterparty_arg_conv;
counterparty_arg_conv.inner = (void*)(counterparty_arg & (~1));
counterparty_arg_conv.is_owned = (counterparty_arg & 1) || (counterparty_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(counterparty_arg_conv);
counterparty_arg_conv = ChannelCounterparty_clone(&counterparty_arg_conv);
LDKOutPoint funding_txo_arg_conv;
funding_txo_arg_conv.inner = (void*)(funding_txo_arg & (~1));
funding_txo_arg_conv.is_owned = (funding_txo_arg & 1) || (funding_txo_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_arg_conv);
funding_txo_arg_conv = OutPoint_clone(&funding_txo_arg_conv);
void* short_channel_id_arg_ptr = (void*)(((uint64_t)short_channel_id_arg) & ~1);
CHECK_ACCESS(short_channel_id_arg_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg) {
+ LDKChannelDetails ret_var = ChannelDetails_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelDetails arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelDetails_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelDetails orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelDetails ret_var = ChannelDetails_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
PaymentSendFailure_free(this_ptr_conv);
}
+static inline uint64_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg) {
+ LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
+ *ret_copy = PaymentSendFailure_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PaymentSendFailure_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKPaymentSendFailure* arg_conv = (LDKPaymentSendFailure*)arg;
+ int64_t ret_val = PaymentSendFailure_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PaymentSendFailure_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKPaymentSendFailure* orig_conv = (LDKPaymentSendFailure*)orig;
LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
LDKRouteParameters failed_paths_retry_conv;
failed_paths_retry_conv.inner = (void*)(failed_paths_retry & (~1));
failed_paths_retry_conv.is_owned = (failed_paths_retry & 1) || (failed_paths_retry == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(failed_paths_retry_conv);
failed_paths_retry_conv = RouteParameters_clone(&failed_paths_retry_conv);
LDKThirtyTwoBytes payment_id_ref;
CHECK((*env)->GetArrayLength(env, payment_id) == 32);
LDKUserConfig config_conv;
config_conv.inner = (void*)(config & (~1));
config_conv.is_owned = (config & 1) || (config == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(config_conv);
config_conv = UserConfig_clone(&config_conv);
LDKChainParameters params_conv;
params_conv.inner = (void*)(params & (~1));
params_conv.is_owned = (params & 1) || (params == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
params_conv = ChainParameters_clone(¶ms_conv);
LDKChannelManager ret_var = ChannelManager_new(fee_est_conv, chain_monitor_conv, tx_broadcaster_conv, logger_conv, keys_manager_conv, config_conv, params_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKUserConfig ret_var = ChannelManager_get_current_default_configuration(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPublicKey their_network_key_ref;
CHECK((*env)->GetArrayLength(env, their_network_key) == 33);
(*env)->GetByteArrayRegion(env, their_network_key, 0, 33, their_network_key_ref.compressed_form);
LDKUserConfig override_config_conv;
override_config_conv.inner = (void*)(override_config & (~1));
override_config_conv.is_owned = (override_config & 1) || (override_config == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(override_config_conv);
override_config_conv = UserConfig_clone(&override_config_conv);
LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
*ret_conv = ChannelManager_create_channel(&this_arg_conv, their_network_key_ref, channel_value_satoshis, push_msat, user_channel_id, override_config_conv);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_channels(&this_arg_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_16_ref = 0;
CHECK((((uint64_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
ret_conv_16_ref = (uint64_t)ret_conv_16_var.inner;
if (ret_conv_16_var.is_owned) {
ret_conv_16_ref |= 1;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_usable_channels(&this_arg_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_16_ref = 0;
CHECK((((uint64_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
ret_conv_16_ref = (uint64_t)ret_conv_16_var.inner;
if (ret_conv_16_var.is_owned) {
ret_conv_16_ref |= 1;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char channel_id_arr[32];
CHECK((*env)->GetArrayLength(env, channel_id) == 32);
(*env)->GetByteArrayRegion(env, channel_id, 0, 32, channel_id_arr);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char channel_id_arr[32];
CHECK((*env)->GetArrayLength(env, channel_id) == 32);
(*env)->GetByteArrayRegion(env, channel_id, 0, 32, channel_id_arr);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char channel_id_arr[32];
CHECK((*env)->GetArrayLength(env, channel_id) == 32);
(*env)->GetByteArrayRegion(env, channel_id, 0, 32, channel_id_arr);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
ChannelManager_force_close_all_channels(&this_arg_conv);
}
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRoute route_conv;
route_conv.inner = (void*)(route & (~1));
route_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
LDKThirtyTwoBytes payment_hash_ref;
CHECK((*env)->GetArrayLength(env, payment_hash) == 32);
(*env)->GetByteArrayRegion(env, payment_hash, 0, 32, payment_hash_ref.data);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRoute route_conv;
route_conv.inner = (void*)(route & (~1));
route_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
LDKThirtyTwoBytes payment_id_ref;
CHECK((*env)->GetArrayLength(env, payment_id) == 32);
(*env)->GetByteArrayRegion(env, payment_id, 0, 32, payment_id_ref.data);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRoute route_conv;
route_conv.inner = (void*)(route & (~1));
route_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
LDKThirtyTwoBytes payment_preimage_ref;
CHECK((*env)->GetArrayLength(env, payment_preimage) == 32);
(*env)->GetByteArrayRegion(env, payment_preimage, 0, 32, payment_preimage_ref.data);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char temporary_channel_id_arr[32];
CHECK((*env)->GetArrayLength(env, temporary_channel_id) == 32);
(*env)->GetByteArrayRegion(env, temporary_channel_id, 0, 32, temporary_channel_id_arr);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKThreeBytes rgb_ref;
CHECK((*env)->GetArrayLength(env, rgb) == 3);
(*env)->GetByteArrayRegion(env, rgb, 0, 3, rgb_ref.data);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
ChannelManager_process_pending_htlc_forwards(&this_arg_conv);
}
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
ChannelManager_timer_tick_occurred(&this_arg_conv);
}
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char payment_hash_arr[32];
CHECK((*env)->GetArrayLength(env, payment_hash) == 32);
(*env)->GetByteArrayRegion(env, payment_hash, 0, 32, payment_hash_arr);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKThirtyTwoBytes payment_preimage_ref;
CHECK((*env)->GetArrayLength(env, payment_preimage) == 32);
(*env)->GetByteArrayRegion(env, payment_preimage, 0, 32, payment_preimage_ref.data);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelManager_get_our_node_id(&this_arg_conv).compressed_form);
return ret_arr;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* min_value_msat_ptr = (void*)(((uint64_t)min_value_msat) & ~1);
CHECK_ACCESS(min_value_msat_ptr);
LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKThirtyTwoBytes payment_hash_ref;
CHECK((*env)->GetArrayLength(env, payment_hash) == 32);
(*env)->GetByteArrayRegion(env, payment_hash, 0, 32, payment_hash_ref.data);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
*ret_ret = ChannelManager_as_MessageSendEventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKEventsProvider* ret_ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
*ret_ret = ChannelManager_as_EventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKListen* ret_ret = MALLOC(sizeof(LDKListen), "LDKListen");
*ret_ret = ChannelManager_as_Listen(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKConfirm* ret_ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
*ret_ret = ChannelManager_as_Confirm(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = ChannelManager_await_persistable_update_timeout(&this_arg_conv, max_wait);
return ret_val;
}
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
ChannelManager_await_persistable_update(&this_arg_conv);
}
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKBestBlock ret_var = ChannelManager_current_best_block(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelMessageHandler* ret_ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
*ret_ret = ChannelManager_as_ChannelMessageHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelManager_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKChannelManagerReadArgs this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelManagerReadArgs_free(this_obj_conv);
}
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)ChannelManagerReadArgs_get_keys_manager(&this_ptr_conv)) | 1;
return ret_ret;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKKeysInterface val_conv = *(LDKKeysInterface*)(val_ptr);
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)ChannelManagerReadArgs_get_fee_estimator(&this_ptr_conv)) | 1;
return ret_ret;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKFeeEstimator val_conv = *(LDKFeeEstimator*)(val_ptr);
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)ChannelManagerReadArgs_get_chain_monitor(&this_ptr_conv)) | 1;
return ret_ret;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKWatch val_conv = *(LDKWatch*)(val_ptr);
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)ChannelManagerReadArgs_get_tx_broadcaster(&this_ptr_conv)) | 1;
return ret_ret;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKBroadcasterInterface val_conv = *(LDKBroadcasterInterface*)(val_ptr);
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)ChannelManagerReadArgs_get_logger(&this_ptr_conv)) | 1;
return ret_ret;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKLogger val_conv = *(LDKLogger*)(val_ptr);
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUserConfig ret_var = ChannelManagerReadArgs_get_default_config(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUserConfig val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = UserConfig_clone(&val_conv);
ChannelManagerReadArgs_set_default_config(&this_ptr_conv, val_conv);
}
LDKUserConfig default_config_conv;
default_config_conv.inner = (void*)(default_config & (~1));
default_config_conv.is_owned = (default_config & 1) || (default_config == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(default_config_conv);
default_config_conv = UserConfig_clone(&default_config_conv);
LDKCVec_ChannelMonitorZ channel_monitors_constr;
channel_monitors_constr.datalen = (*env)->GetArrayLength(env, channel_monitors);
LDKChannelMonitor channel_monitors_conv_16_conv;
channel_monitors_conv_16_conv.inner = (void*)(channel_monitors_conv_16 & (~1));
channel_monitors_conv_16_conv.is_owned = (channel_monitors_conv_16 & 1) || (channel_monitors_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_monitors_conv_16_conv);
channel_monitors_constr.data[q] = channel_monitors_conv_16_conv;
}
(*env)->ReleaseLongArrayElements(env, channel_monitors, channel_monitors_vals, 0);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelManagerReadArgs arg_conv;
arg_conv.inner = (void*)(arg & (~1));
arg_conv.is_owned = (arg & 1) || (arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
// Warning: we need a move here but no clone is available for LDKChannelManagerReadArgs
LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
*ret_conv = C2Tuple_BlockHashChannelManagerZ_read(ser_ref, arg_conv);
LDKDecodeError this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DecodeError_free(this_obj_conv);
}
+static inline uint64_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg) {
+ LDKDecodeError ret_var = DecodeError_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DecodeError_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKDecodeError arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = DecodeError_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DecodeError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKDecodeError orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKDecodeError ret_var = DecodeError_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInit this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Init_free(this_obj_conv);
}
LDKInit this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInitFeatures ret_var = Init_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInit this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInitFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = InitFeatures_clone(&val_conv);
Init_set_features(&this_ptr_conv, val_conv);
}
LDKInitFeatures features_arg_conv;
features_arg_conv.inner = (void*)(features_arg & (~1));
features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
features_arg_conv = InitFeatures_clone(&features_arg_conv);
LDKInit ret_var = Init_new(features_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Init_clone_ptr(LDKInit *NONNULL_PTR arg) {
+ LDKInit ret_var = Init_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Init_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKInit arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Init_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Init_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKInit orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInit ret_var = Init_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKErrorMessage this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ErrorMessage_free(this_obj_conv);
}
LDKErrorMessage this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ErrorMessage_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKErrorMessage this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKErrorMessage this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr ret_str = ErrorMessage_get_data(&this_ptr_conv);
jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
Str_free(ret_str);
LDKErrorMessage this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr val_conv = java_to_owned_str(env, val);
ErrorMessage_set_data(&this_ptr_conv, val_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg) {
+ LDKErrorMessage ret_var = ErrorMessage_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKErrorMessage arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ErrorMessage_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKErrorMessage orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKErrorMessage ret_var = ErrorMessage_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPing this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Ping_free(this_obj_conv);
}
LDKPing this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = Ping_get_ponglen(&this_ptr_conv);
return ret_val;
}
LDKPing this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
Ping_set_ponglen(&this_ptr_conv, val);
}
LDKPing this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = Ping_get_byteslen(&this_ptr_conv);
return ret_val;
}
LDKPing this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
Ping_set_byteslen(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg) {
+ LDKPing ret_var = Ping_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Ping_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKPing arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Ping_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Ping_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKPing orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPing ret_var = Ping_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPong this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Pong_free(this_obj_conv);
}
LDKPong this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = Pong_get_byteslen(&this_ptr_conv);
return ret_val;
}
LDKPong this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
Pong_set_byteslen(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg) {
+ LDKPong ret_var = Pong_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Pong_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKPong arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Pong_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Pong_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKPong orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPong ret_var = Pong_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKOpenChannel this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
OpenChannel_free(this_obj_conv);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *OpenChannel_get_chain_hash(&this_ptr_conv));
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *OpenChannel_get_temporary_channel_id(&this_ptr_conv));
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_funding_satoshis(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_funding_satoshis(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_push_msat(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_push_msat(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_dust_limit_satoshis(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_channel_reserve_satoshis(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = OpenChannel_get_feerate_per_kw(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_feerate_per_kw(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = OpenChannel_get_to_self_delay(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_to_self_delay(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = OpenChannel_get_max_accepted_htlcs(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_funding_pubkey(&this_ptr_conv).compressed_form);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_payment_point(&this_ptr_conv).compressed_form);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, OpenChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_t ret_val = OpenChannel_get_channel_flags(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_channel_flags(&this_ptr_conv, val);
}
+static inline uint64_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg) {
+ LDKOpenChannel ret_var = OpenChannel_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKOpenChannel arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = OpenChannel_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_OpenChannel_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKOpenChannel orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKOpenChannel ret_var = OpenChannel_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKAcceptChannel this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
AcceptChannel_free(this_obj_conv);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *AcceptChannel_get_temporary_channel_id(&this_ptr_conv));
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = AcceptChannel_get_dust_limit_satoshis(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = AcceptChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = AcceptChannel_get_channel_reserve_satoshis(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = AcceptChannel_get_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = AcceptChannel_get_minimum_depth(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_minimum_depth(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = AcceptChannel_get_to_self_delay(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_to_self_delay(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = AcceptChannel_get_max_accepted_htlcs(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_funding_pubkey(&this_ptr_conv).compressed_form);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_payment_point(&this_ptr_conv).compressed_form);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, AcceptChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
AcceptChannel_set_first_per_commitment_point(&this_ptr_conv, val_ref);
}
+static inline uint64_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg) {
+ LDKAcceptChannel ret_var = AcceptChannel_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKAcceptChannel arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = AcceptChannel_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKAcceptChannel orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKAcceptChannel ret_var = AcceptChannel_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKFundingCreated this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
FundingCreated_free(this_obj_conv);
}
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *FundingCreated_get_temporary_channel_id(&this_ptr_conv));
return ret_arr;
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *FundingCreated_get_funding_txid(&this_ptr_conv));
return ret_arr;
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = FundingCreated_get_funding_output_index(&this_ptr_conv);
return ret_val;
}
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
FundingCreated_set_funding_output_index(&this_ptr_conv, val);
}
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, FundingCreated_get_signature(&this_ptr_conv).compact_form);
return ret_arr;
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg) {
+ LDKFundingCreated ret_var = FundingCreated_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingCreated_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKFundingCreated arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = FundingCreated_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingCreated_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKFundingCreated orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKFundingCreated ret_var = FundingCreated_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKFundingSigned this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
FundingSigned_free(this_obj_conv);
}
LDKFundingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *FundingSigned_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKFundingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKFundingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, FundingSigned_get_signature(&this_ptr_conv).compact_form);
return ret_arr;
LDKFundingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg) {
+ LDKFundingSigned ret_var = FundingSigned_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingSigned_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKFundingSigned arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = FundingSigned_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingSigned_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKFundingSigned orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKFundingSigned ret_var = FundingSigned_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKFundingLocked this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
FundingLocked_free(this_obj_conv);
}
LDKFundingLocked this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *FundingLocked_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKFundingLocked this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKFundingLocked this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, FundingLocked_get_next_per_commitment_point(&this_ptr_conv).compressed_form);
return ret_arr;
LDKFundingLocked this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t FundingLocked_clone_ptr(LDKFundingLocked *NONNULL_PTR arg) {
+ LDKFundingLocked ret_var = FundingLocked_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingLocked_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKFundingLocked arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = FundingLocked_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_FundingLocked_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKFundingLocked orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKFundingLocked ret_var = FundingLocked_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKShutdown this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Shutdown_free(this_obj_conv);
}
LDKShutdown this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *Shutdown_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKShutdown this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKShutdown this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKu8slice ret_var = Shutdown_get_scriptpubkey(&this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKShutdown this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u8Z val_ref;
val_ref.datalen = (*env)->GetArrayLength(env, val);
val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg) {
+ LDKShutdown ret_var = Shutdown_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Shutdown_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKShutdown arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Shutdown_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Shutdown_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKShutdown orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKShutdown ret_var = Shutdown_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingSignedFeeRange this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ClosingSignedFeeRange_free(this_obj_conv);
}
LDKClosingSignedFeeRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ClosingSignedFeeRange_get_min_fee_satoshis(&this_ptr_conv);
return ret_val;
}
LDKClosingSignedFeeRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ClosingSignedFeeRange_set_min_fee_satoshis(&this_ptr_conv, val);
}
LDKClosingSignedFeeRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ClosingSignedFeeRange_get_max_fee_satoshis(&this_ptr_conv);
return ret_val;
}
LDKClosingSignedFeeRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ClosingSignedFeeRange_set_max_fee_satoshis(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg) {
+ LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosingSignedFeeRange_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKClosingSignedFeeRange arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ClosingSignedFeeRange_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosingSignedFeeRange_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKClosingSignedFeeRange orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingSigned this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ClosingSigned_free(this_obj_conv);
}
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ClosingSigned_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ClosingSigned_get_fee_satoshis(&this_ptr_conv);
return ret_val;
}
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ClosingSigned_set_fee_satoshis(&this_ptr_conv, val);
}
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ClosingSigned_get_signature(&this_ptr_conv).compact_form);
return ret_arr;
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKClosingSignedFeeRange ret_var = ClosingSigned_get_fee_range(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKClosingSignedFeeRange val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ClosingSignedFeeRange_clone(&val_conv);
ClosingSigned_set_fee_range(&this_ptr_conv, val_conv);
}
LDKClosingSignedFeeRange fee_range_arg_conv;
fee_range_arg_conv.inner = (void*)(fee_range_arg & (~1));
fee_range_arg_conv.is_owned = (fee_range_arg & 1) || (fee_range_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(fee_range_arg_conv);
fee_range_arg_conv = ClosingSignedFeeRange_clone(&fee_range_arg_conv);
LDKClosingSigned ret_var = ClosingSigned_new(channel_id_arg_ref, fee_satoshis_arg, signature_arg_ref, fee_range_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg) {
+ LDKClosingSigned ret_var = ClosingSigned_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKClosingSigned arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ClosingSigned_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKClosingSigned orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKClosingSigned ret_var = ClosingSigned_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUpdateAddHTLC this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UpdateAddHTLC_free(this_obj_conv);
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateAddHTLC_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UpdateAddHTLC_get_htlc_id(&this_ptr_conv);
return ret_val;
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateAddHTLC_set_htlc_id(&this_ptr_conv, val);
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UpdateAddHTLC_get_amount_msat(&this_ptr_conv);
return ret_val;
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateAddHTLC_set_amount_msat(&this_ptr_conv, val);
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateAddHTLC_get_payment_hash(&this_ptr_conv));
return ret_arr;
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UpdateAddHTLC_get_cltv_expiry(&this_ptr_conv);
return ret_val;
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateAddHTLC_set_cltv_expiry(&this_ptr_conv, val);
}
+static inline uint64_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg) {
+ LDKUpdateAddHTLC ret_var = UpdateAddHTLC_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKUpdateAddHTLC arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UpdateAddHTLC_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKUpdateAddHTLC orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUpdateAddHTLC ret_var = UpdateAddHTLC_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUpdateFulfillHTLC this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UpdateFulfillHTLC_free(this_obj_conv);
}
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateFulfillHTLC_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UpdateFulfillHTLC_get_htlc_id(&this_ptr_conv);
return ret_val;
}
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateFulfillHTLC_set_htlc_id(&this_ptr_conv, val);
}
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateFulfillHTLC_get_payment_preimage(&this_ptr_conv));
return ret_arr;
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg) {
+ LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKUpdateFulfillHTLC arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UpdateFulfillHTLC_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKUpdateFulfillHTLC orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUpdateFailHTLC this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UpdateFailHTLC_free(this_obj_conv);
}
LDKUpdateFailHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateFailHTLC_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKUpdateFailHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKUpdateFailHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UpdateFailHTLC_get_htlc_id(&this_ptr_conv);
return ret_val;
}
LDKUpdateFailHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateFailHTLC_set_htlc_id(&this_ptr_conv, val);
}
+static inline uint64_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg) {
+ LDKUpdateFailHTLC ret_var = UpdateFailHTLC_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFailHTLC_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKUpdateFailHTLC arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UpdateFailHTLC_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFailHTLC_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKUpdateFailHTLC orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUpdateFailHTLC ret_var = UpdateFailHTLC_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUpdateFailMalformedHTLC this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UpdateFailMalformedHTLC_free(this_obj_conv);
}
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateFailMalformedHTLC_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UpdateFailMalformedHTLC_get_htlc_id(&this_ptr_conv);
return ret_val;
}
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateFailMalformedHTLC_set_htlc_id(&this_ptr_conv, val);
}
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = UpdateFailMalformedHTLC_get_failure_code(&this_ptr_conv);
return ret_val;
}
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateFailMalformedHTLC_set_failure_code(&this_ptr_conv, val);
}
+static inline uint64_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg) {
+ LDKUpdateFailMalformedHTLC ret_var = UpdateFailMalformedHTLC_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKUpdateFailMalformedHTLC arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UpdateFailMalformedHTLC_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKUpdateFailMalformedHTLC orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUpdateFailMalformedHTLC ret_var = UpdateFailMalformedHTLC_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentSigned this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
CommitmentSigned_free(this_obj_conv);
}
LDKCommitmentSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *CommitmentSigned_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKCommitmentSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKCommitmentSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, CommitmentSigned_get_signature(&this_ptr_conv).compact_form);
return ret_arr;
LDKCommitmentSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
LDKCommitmentSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_SignatureZ val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg) {
+ LDKCommitmentSigned ret_var = CommitmentSigned_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCommitmentSigned arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = CommitmentSigned_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCommitmentSigned orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKCommitmentSigned ret_var = CommitmentSigned_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRevokeAndACK this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RevokeAndACK_free(this_obj_conv);
}
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *RevokeAndACK_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *RevokeAndACK_get_per_commitment_secret(&this_ptr_conv));
return ret_arr;
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, RevokeAndACK_get_next_per_commitment_point(&this_ptr_conv).compressed_form);
return ret_arr;
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg) {
+ LDKRevokeAndACK ret_var = RevokeAndACK_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKRevokeAndACK arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RevokeAndACK_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKRevokeAndACK orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRevokeAndACK ret_var = RevokeAndACK_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUpdateFee this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UpdateFee_free(this_obj_conv);
}
LDKUpdateFee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UpdateFee_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKUpdateFee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKUpdateFee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UpdateFee_get_feerate_per_kw(&this_ptr_conv);
return ret_val;
}
LDKUpdateFee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateFee_set_feerate_per_kw(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg) {
+ LDKUpdateFee ret_var = UpdateFee_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFee_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKUpdateFee arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UpdateFee_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UpdateFee_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKUpdateFee orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUpdateFee ret_var = UpdateFee_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDataLossProtect this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DataLossProtect_free(this_obj_conv);
}
LDKDataLossProtect this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *DataLossProtect_get_your_last_per_commitment_secret(&this_ptr_conv));
return ret_arr;
LDKDataLossProtect this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKDataLossProtect this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, DataLossProtect_get_my_current_per_commitment_point(&this_ptr_conv).compressed_form);
return ret_arr;
LDKDataLossProtect this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg) {
+ LDKDataLossProtect ret_var = DataLossProtect_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DataLossProtect_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKDataLossProtect arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = DataLossProtect_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DataLossProtect_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKDataLossProtect orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKDataLossProtect ret_var = DataLossProtect_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelReestablish this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelReestablish_free(this_obj_conv);
}
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ChannelReestablish_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelReestablish_get_next_local_commitment_number(&this_ptr_conv);
return ret_val;
}
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelReestablish_set_next_local_commitment_number(&this_ptr_conv, val);
}
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelReestablish_get_next_remote_commitment_number(&this_ptr_conv);
return ret_val;
}
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelReestablish_set_next_remote_commitment_number(&this_ptr_conv, val);
}
+static inline uint64_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg) {
+ LDKChannelReestablish ret_var = ChannelReestablish_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelReestablish arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelReestablish_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelReestablish orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelReestablish ret_var = ChannelReestablish_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKAnnouncementSignatures this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
AnnouncementSignatures_free(this_obj_conv);
}
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *AnnouncementSignatures_get_channel_id(&this_ptr_conv));
return ret_arr;
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = AnnouncementSignatures_get_short_channel_id(&this_ptr_conv);
return ret_val;
}
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AnnouncementSignatures_set_short_channel_id(&this_ptr_conv, val);
}
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, AnnouncementSignatures_get_node_signature(&this_ptr_conv).compact_form);
return ret_arr;
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, AnnouncementSignatures_get_bitcoin_signature(&this_ptr_conv).compact_form);
return ret_arr;
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg) {
+ LDKAnnouncementSignatures ret_var = AnnouncementSignatures_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKAnnouncementSignatures arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = AnnouncementSignatures_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKAnnouncementSignatures orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKAnnouncementSignatures ret_var = AnnouncementSignatures_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
NetAddress_free(this_ptr_conv);
}
+static inline uint64_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg) {
+ LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
+ *ret_copy = NetAddress_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetAddress_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKNetAddress* arg_conv = (LDKNetAddress*)arg;
+ int64_t ret_val = NetAddress_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetAddress_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKNetAddress* orig_conv = (LDKNetAddress*)orig;
LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
LDKUnsignedNodeAnnouncement this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UnsignedNodeAnnouncement_free(this_obj_conv);
}
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures ret_var = UnsignedNodeAnnouncement_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeFeatures_clone(&val_conv);
UnsignedNodeAnnouncement_set_features(&this_ptr_conv, val_conv);
}
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UnsignedNodeAnnouncement_get_timestamp(&this_ptr_conv);
return ret_val;
}
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedNodeAnnouncement_set_timestamp(&this_ptr_conv, val);
}
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, UnsignedNodeAnnouncement_get_node_id(&this_ptr_conv).compressed_form);
return ret_arr;
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 3);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 3, *UnsignedNodeAnnouncement_get_rgb(&this_ptr_conv));
return ret_arr;
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThreeBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 3);
(*env)->GetByteArrayRegion(env, val, 0, 3, val_ref.data);
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UnsignedNodeAnnouncement_get_alias(&this_ptr_conv));
return ret_arr;
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_NetAddressZ val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
UnsignedNodeAnnouncement_set_addresses(&this_ptr_conv, val_constr);
}
+static inline uint64_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg) {
+ LDKUnsignedNodeAnnouncement ret_var = UnsignedNodeAnnouncement_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKUnsignedNodeAnnouncement arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UnsignedNodeAnnouncement_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKUnsignedNodeAnnouncement orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUnsignedNodeAnnouncement ret_var = UnsignedNodeAnnouncement_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeAnnouncement this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NodeAnnouncement_free(this_obj_conv);
}
LDKNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, NodeAnnouncement_get_signature(&this_ptr_conv).compact_form);
return ret_arr;
LDKNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
LDKNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedNodeAnnouncement ret_var = NodeAnnouncement_get_contents(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedNodeAnnouncement val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = UnsignedNodeAnnouncement_clone(&val_conv);
NodeAnnouncement_set_contents(&this_ptr_conv, val_conv);
}
LDKUnsignedNodeAnnouncement contents_arg_conv;
contents_arg_conv.inner = (void*)(contents_arg & (~1));
contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
contents_arg_conv = UnsignedNodeAnnouncement_clone(&contents_arg_conv);
LDKNodeAnnouncement ret_var = NodeAnnouncement_new(signature_arg_ref, contents_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg) {
+ LDKNodeAnnouncement ret_var = NodeAnnouncement_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKNodeAnnouncement arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NodeAnnouncement_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKNodeAnnouncement orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNodeAnnouncement ret_var = NodeAnnouncement_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUnsignedChannelAnnouncement this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UnsignedChannelAnnouncement_free(this_obj_conv);
}
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures ret_var = UnsignedChannelAnnouncement_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelFeatures_clone(&val_conv);
UnsignedChannelAnnouncement_set_features(&this_ptr_conv, val_conv);
}
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UnsignedChannelAnnouncement_get_chain_hash(&this_ptr_conv));
return ret_arr;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UnsignedChannelAnnouncement_get_short_channel_id(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelAnnouncement_set_short_channel_id(&this_ptr_conv, val);
}
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, UnsignedChannelAnnouncement_get_node_id_1(&this_ptr_conv).compressed_form);
return ret_arr;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, UnsignedChannelAnnouncement_get_node_id_2(&this_ptr_conv).compressed_form);
return ret_arr;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, UnsignedChannelAnnouncement_get_bitcoin_key_1(&this_ptr_conv).compressed_form);
return ret_arr;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, UnsignedChannelAnnouncement_get_bitcoin_key_2(&this_ptr_conv).compressed_form);
return ret_arr;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
UnsignedChannelAnnouncement_set_bitcoin_key_2(&this_ptr_conv, val_ref);
}
+static inline uint64_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg) {
+ LDKUnsignedChannelAnnouncement ret_var = UnsignedChannelAnnouncement_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKUnsignedChannelAnnouncement arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UnsignedChannelAnnouncement_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKUnsignedChannelAnnouncement orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUnsignedChannelAnnouncement ret_var = UnsignedChannelAnnouncement_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelAnnouncement this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelAnnouncement_free(this_obj_conv);
}
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ChannelAnnouncement_get_node_signature_1(&this_ptr_conv).compact_form);
return ret_arr;
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ChannelAnnouncement_get_node_signature_2(&this_ptr_conv).compact_form);
return ret_arr;
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ChannelAnnouncement_get_bitcoin_signature_1(&this_ptr_conv).compact_form);
return ret_arr;
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ChannelAnnouncement_get_bitcoin_signature_2(&this_ptr_conv).compact_form);
return ret_arr;
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedChannelAnnouncement ret_var = ChannelAnnouncement_get_contents(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedChannelAnnouncement val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = UnsignedChannelAnnouncement_clone(&val_conv);
ChannelAnnouncement_set_contents(&this_ptr_conv, val_conv);
}
LDKUnsignedChannelAnnouncement contents_arg_conv;
contents_arg_conv.inner = (void*)(contents_arg & (~1));
contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
contents_arg_conv = UnsignedChannelAnnouncement_clone(&contents_arg_conv);
LDKChannelAnnouncement ret_var = ChannelAnnouncement_new(node_signature_1_arg_ref, node_signature_2_arg_ref, bitcoin_signature_1_arg_ref, bitcoin_signature_2_arg_ref, contents_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg) {
+ LDKChannelAnnouncement ret_var = ChannelAnnouncement_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelAnnouncement arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelAnnouncement_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelAnnouncement orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelAnnouncement ret_var = ChannelAnnouncement_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUnsignedChannelUpdate this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UnsignedChannelUpdate_free(this_obj_conv);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *UnsignedChannelUpdate_get_chain_hash(&this_ptr_conv));
return ret_arr;
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UnsignedChannelUpdate_get_short_channel_id(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_short_channel_id(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UnsignedChannelUpdate_get_timestamp(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_timestamp(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_t ret_val = UnsignedChannelUpdate_get_flags(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_flags(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = UnsignedChannelUpdate_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UnsignedChannelUpdate_get_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_htlc_minimum_msat(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UnsignedChannelUpdate_get_fee_base_msat(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_fee_base_msat(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UnsignedChannelUpdate_get_fee_proportional_millionths(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_fee_proportional_millionths(&this_ptr_conv, val);
}
+static inline uint64_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg) {
+ LDKUnsignedChannelUpdate ret_var = UnsignedChannelUpdate_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKUnsignedChannelUpdate arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UnsignedChannelUpdate_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKUnsignedChannelUpdate orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUnsignedChannelUpdate ret_var = UnsignedChannelUpdate_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelUpdate this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelUpdate_free(this_obj_conv);
}
LDKChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, ChannelUpdate_get_signature(&this_ptr_conv).compact_form);
return ret_arr;
LDKChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
LDKChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedChannelUpdate ret_var = ChannelUpdate_get_contents(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedChannelUpdate val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = UnsignedChannelUpdate_clone(&val_conv);
ChannelUpdate_set_contents(&this_ptr_conv, val_conv);
}
LDKUnsignedChannelUpdate contents_arg_conv;
contents_arg_conv.inner = (void*)(contents_arg & (~1));
contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
contents_arg_conv = UnsignedChannelUpdate_clone(&contents_arg_conv);
LDKChannelUpdate ret_var = ChannelUpdate_new(signature_arg_ref, contents_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg) {
+ LDKChannelUpdate ret_var = ChannelUpdate_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelUpdate arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelUpdate_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelUpdate orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelUpdate ret_var = ChannelUpdate_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKQueryChannelRange this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
QueryChannelRange_free(this_obj_conv);
}
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *QueryChannelRange_get_chain_hash(&this_ptr_conv));
return ret_arr;
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = QueryChannelRange_get_first_blocknum(&this_ptr_conv);
return ret_val;
}
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
QueryChannelRange_set_first_blocknum(&this_ptr_conv, val);
}
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = QueryChannelRange_get_number_of_blocks(&this_ptr_conv);
return ret_val;
}
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
QueryChannelRange_set_number_of_blocks(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg) {
+ LDKQueryChannelRange ret_var = QueryChannelRange_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKQueryChannelRange arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = QueryChannelRange_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKQueryChannelRange orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKQueryChannelRange ret_var = QueryChannelRange_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKReplyChannelRange this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ReplyChannelRange_free(this_obj_conv);
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ReplyChannelRange_get_chain_hash(&this_ptr_conv));
return ret_arr;
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ReplyChannelRange_get_first_blocknum(&this_ptr_conv);
return ret_val;
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ReplyChannelRange_set_first_blocknum(&this_ptr_conv, val);
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ReplyChannelRange_get_number_of_blocks(&this_ptr_conv);
return ret_val;
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ReplyChannelRange_set_number_of_blocks(&this_ptr_conv, val);
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ReplyChannelRange_get_sync_complete(&this_ptr_conv);
return ret_val;
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ReplyChannelRange_set_sync_complete(&this_ptr_conv, val);
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u64Z val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg) {
+ LDKReplyChannelRange ret_var = ReplyChannelRange_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKReplyChannelRange arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ReplyChannelRange_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKReplyChannelRange orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKReplyChannelRange ret_var = ReplyChannelRange_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKQueryShortChannelIds this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
QueryShortChannelIds_free(this_obj_conv);
}
LDKQueryShortChannelIds this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *QueryShortChannelIds_get_chain_hash(&this_ptr_conv));
return ret_arr;
LDKQueryShortChannelIds this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKQueryShortChannelIds this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u64Z val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg) {
+ LDKQueryShortChannelIds ret_var = QueryShortChannelIds_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_QueryShortChannelIds_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKQueryShortChannelIds arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = QueryShortChannelIds_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_QueryShortChannelIds_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKQueryShortChannelIds orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKQueryShortChannelIds ret_var = QueryShortChannelIds_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKReplyShortChannelIdsEnd this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ReplyShortChannelIdsEnd_free(this_obj_conv);
}
LDKReplyShortChannelIdsEnd this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *ReplyShortChannelIdsEnd_get_chain_hash(&this_ptr_conv));
return ret_arr;
LDKReplyShortChannelIdsEnd this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKReplyShortChannelIdsEnd this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ReplyShortChannelIdsEnd_get_full_information(&this_ptr_conv);
return ret_val;
}
LDKReplyShortChannelIdsEnd this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ReplyShortChannelIdsEnd_set_full_information(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg) {
+ LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKReplyShortChannelIdsEnd arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ReplyShortChannelIdsEnd_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKReplyShortChannelIdsEnd orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKGossipTimestampFilter this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
GossipTimestampFilter_free(this_obj_conv);
}
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *GossipTimestampFilter_get_chain_hash(&this_ptr_conv));
return ret_arr;
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = GossipTimestampFilter_get_first_timestamp(&this_ptr_conv);
return ret_val;
}
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
GossipTimestampFilter_set_first_timestamp(&this_ptr_conv, val);
}
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = GossipTimestampFilter_get_timestamp_range(&this_ptr_conv);
return ret_val;
}
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
GossipTimestampFilter_set_timestamp_range(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg) {
+ LDKGossipTimestampFilter ret_var = GossipTimestampFilter_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKGossipTimestampFilter arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = GossipTimestampFilter_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKGossipTimestampFilter orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKGossipTimestampFilter ret_var = GossipTimestampFilter_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
ErrorAction_free(this_ptr_conv);
}
+static inline uint64_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg) {
+ LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
+ *ret_copy = ErrorAction_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErrorAction_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKErrorAction* arg_conv = (LDKErrorAction*)arg;
+ int64_t ret_val = ErrorAction_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ErrorAction_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKErrorAction* orig_conv = (LDKErrorAction*)orig;
LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
LDKErrorMessage msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ErrorMessage_clone(&msg_conv);
LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
*ret_copy = ErrorAction_disconnect_peer(msg_conv);
LDKErrorMessage msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ErrorMessage_clone(&msg_conv);
LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
*ret_copy = ErrorAction_send_error_message(msg_conv);
LDKLightningError this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
LightningError_free(this_obj_conv);
}
LDKLightningError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr ret_str = LightningError_get_err(&this_ptr_conv);
jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
Str_free(ret_str);
LDKLightningError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr val_conv = java_to_owned_str(env, val);
LightningError_set_err(&this_ptr_conv, val_conv);
}
LDKLightningError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
*ret_copy = LightningError_get_action(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKLightningError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKErrorAction val_conv = *(LDKErrorAction*)(val_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg) {
+ LDKLightningError ret_var = LightningError_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LightningError_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKLightningError arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = LightningError_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_LightningError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKLightningError orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKLightningError ret_var = LightningError_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentUpdate this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
CommitmentUpdate_free(this_obj_conv);
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateAddHTLCZ ret_var = CommitmentUpdate_get_update_add_htlcs(&this_ptr_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_15_ref = 0;
CHECK((((uint64_t)ret_conv_15_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_15_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_15_var);
ret_conv_15_ref = (uint64_t)ret_conv_15_var.inner;
if (ret_conv_15_var.is_owned) {
ret_conv_15_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateAddHTLCZ val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
LDKUpdateAddHTLC val_conv_15_conv;
val_conv_15_conv.inner = (void*)(val_conv_15 & (~1));
val_conv_15_conv.is_owned = (val_conv_15 & 1) || (val_conv_15 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_15_conv);
val_conv_15_conv = UpdateAddHTLC_clone(&val_conv_15_conv);
val_constr.data[p] = val_conv_15_conv;
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFulfillHTLCZ ret_var = CommitmentUpdate_get_update_fulfill_htlcs(&this_ptr_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_19_ref = 0;
CHECK((((uint64_t)ret_conv_19_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_19_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_19_var);
ret_conv_19_ref = (uint64_t)ret_conv_19_var.inner;
if (ret_conv_19_var.is_owned) {
ret_conv_19_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFulfillHTLCZ val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
LDKUpdateFulfillHTLC val_conv_19_conv;
val_conv_19_conv.inner = (void*)(val_conv_19 & (~1));
val_conv_19_conv.is_owned = (val_conv_19 & 1) || (val_conv_19 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_19_conv);
val_conv_19_conv = UpdateFulfillHTLC_clone(&val_conv_19_conv);
val_constr.data[t] = val_conv_19_conv;
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFailHTLCZ ret_var = CommitmentUpdate_get_update_fail_htlcs(&this_ptr_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_16_ref = 0;
CHECK((((uint64_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
ret_conv_16_ref = (uint64_t)ret_conv_16_var.inner;
if (ret_conv_16_var.is_owned) {
ret_conv_16_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFailHTLCZ val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
LDKUpdateFailHTLC val_conv_16_conv;
val_conv_16_conv.inner = (void*)(val_conv_16 & (~1));
val_conv_16_conv.is_owned = (val_conv_16 & 1) || (val_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_16_conv);
val_conv_16_conv = UpdateFailHTLC_clone(&val_conv_16_conv);
val_constr.data[q] = val_conv_16_conv;
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFailMalformedHTLCZ ret_var = CommitmentUpdate_get_update_fail_malformed_htlcs(&this_ptr_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_25_ref = 0;
CHECK((((uint64_t)ret_conv_25_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_25_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_25_var);
ret_conv_25_ref = (uint64_t)ret_conv_25_var.inner;
if (ret_conv_25_var.is_owned) {
ret_conv_25_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFailMalformedHTLCZ val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
LDKUpdateFailMalformedHTLC val_conv_25_conv;
val_conv_25_conv.inner = (void*)(val_conv_25 & (~1));
val_conv_25_conv.is_owned = (val_conv_25 & 1) || (val_conv_25 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_25_conv);
val_conv_25_conv = UpdateFailMalformedHTLC_clone(&val_conv_25_conv);
val_constr.data[z] = val_conv_25_conv;
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUpdateFee ret_var = CommitmentUpdate_get_update_fee(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUpdateFee val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = UpdateFee_clone(&val_conv);
CommitmentUpdate_set_update_fee(&this_ptr_conv, val_conv);
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCommitmentSigned ret_var = CommitmentUpdate_get_commitment_signed(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCommitmentSigned val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = CommitmentSigned_clone(&val_conv);
CommitmentUpdate_set_commitment_signed(&this_ptr_conv, val_conv);
}
LDKUpdateAddHTLC update_add_htlcs_arg_conv_15_conv;
update_add_htlcs_arg_conv_15_conv.inner = (void*)(update_add_htlcs_arg_conv_15 & (~1));
update_add_htlcs_arg_conv_15_conv.is_owned = (update_add_htlcs_arg_conv_15 & 1) || (update_add_htlcs_arg_conv_15 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_add_htlcs_arg_conv_15_conv);
update_add_htlcs_arg_conv_15_conv = UpdateAddHTLC_clone(&update_add_htlcs_arg_conv_15_conv);
update_add_htlcs_arg_constr.data[p] = update_add_htlcs_arg_conv_15_conv;
}
LDKUpdateFulfillHTLC update_fulfill_htlcs_arg_conv_19_conv;
update_fulfill_htlcs_arg_conv_19_conv.inner = (void*)(update_fulfill_htlcs_arg_conv_19 & (~1));
update_fulfill_htlcs_arg_conv_19_conv.is_owned = (update_fulfill_htlcs_arg_conv_19 & 1) || (update_fulfill_htlcs_arg_conv_19 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fulfill_htlcs_arg_conv_19_conv);
update_fulfill_htlcs_arg_conv_19_conv = UpdateFulfillHTLC_clone(&update_fulfill_htlcs_arg_conv_19_conv);
update_fulfill_htlcs_arg_constr.data[t] = update_fulfill_htlcs_arg_conv_19_conv;
}
LDKUpdateFailHTLC update_fail_htlcs_arg_conv_16_conv;
update_fail_htlcs_arg_conv_16_conv.inner = (void*)(update_fail_htlcs_arg_conv_16 & (~1));
update_fail_htlcs_arg_conv_16_conv.is_owned = (update_fail_htlcs_arg_conv_16 & 1) || (update_fail_htlcs_arg_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fail_htlcs_arg_conv_16_conv);
update_fail_htlcs_arg_conv_16_conv = UpdateFailHTLC_clone(&update_fail_htlcs_arg_conv_16_conv);
update_fail_htlcs_arg_constr.data[q] = update_fail_htlcs_arg_conv_16_conv;
}
LDKUpdateFailMalformedHTLC update_fail_malformed_htlcs_arg_conv_25_conv;
update_fail_malformed_htlcs_arg_conv_25_conv.inner = (void*)(update_fail_malformed_htlcs_arg_conv_25 & (~1));
update_fail_malformed_htlcs_arg_conv_25_conv.is_owned = (update_fail_malformed_htlcs_arg_conv_25 & 1) || (update_fail_malformed_htlcs_arg_conv_25 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fail_malformed_htlcs_arg_conv_25_conv);
update_fail_malformed_htlcs_arg_conv_25_conv = UpdateFailMalformedHTLC_clone(&update_fail_malformed_htlcs_arg_conv_25_conv);
update_fail_malformed_htlcs_arg_constr.data[z] = update_fail_malformed_htlcs_arg_conv_25_conv;
}
LDKUpdateFee update_fee_arg_conv;
update_fee_arg_conv.inner = (void*)(update_fee_arg & (~1));
update_fee_arg_conv.is_owned = (update_fee_arg & 1) || (update_fee_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fee_arg_conv);
update_fee_arg_conv = UpdateFee_clone(&update_fee_arg_conv);
LDKCommitmentSigned commitment_signed_arg_conv;
commitment_signed_arg_conv.inner = (void*)(commitment_signed_arg & (~1));
commitment_signed_arg_conv.is_owned = (commitment_signed_arg & 1) || (commitment_signed_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_signed_arg_conv);
commitment_signed_arg_conv = CommitmentSigned_clone(&commitment_signed_arg_conv);
LDKCommitmentUpdate ret_var = CommitmentUpdate_new(update_add_htlcs_arg_constr, update_fulfill_htlcs_arg_constr, update_fail_htlcs_arg_constr, update_fail_malformed_htlcs_arg_constr, update_fee_arg_conv, commitment_signed_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg) {
+ LDKCommitmentUpdate ret_var = CommitmentUpdate_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCommitmentUpdate arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = CommitmentUpdate_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCommitmentUpdate orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKCommitmentUpdate ret_var = CommitmentUpdate_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKAcceptChannel obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = AcceptChannel_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKAnnouncementSignatures obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = AnnouncementSignatures_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKChannelReestablish obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelReestablish_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKClosingSigned obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ClosingSigned_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKClosingSignedFeeRange obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ClosingSignedFeeRange_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKCommitmentSigned obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = CommitmentSigned_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKFundingCreated obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = FundingCreated_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKFundingSigned obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = FundingSigned_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKFundingLocked obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = FundingLocked_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKInit obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Init_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKOpenChannel obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = OpenChannel_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKRevokeAndACK obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RevokeAndACK_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKShutdown obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Shutdown_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKUpdateFailHTLC obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UpdateFailHTLC_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKUpdateFailMalformedHTLC obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UpdateFailMalformedHTLC_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKUpdateFee obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UpdateFee_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKUpdateFulfillHTLC obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UpdateFulfillHTLC_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKUpdateAddHTLC obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UpdateAddHTLC_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKPing obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Ping_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKPong obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Pong_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKUnsignedChannelAnnouncement obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UnsignedChannelAnnouncement_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKChannelAnnouncement obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelAnnouncement_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKUnsignedChannelUpdate obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UnsignedChannelUpdate_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKChannelUpdate obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelUpdate_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKErrorMessage obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ErrorMessage_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKUnsignedNodeAnnouncement obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UnsignedNodeAnnouncement_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKNodeAnnouncement obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NodeAnnouncement_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKQueryShortChannelIds obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = QueryShortChannelIds_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKReplyShortChannelIdsEnd obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ReplyShortChannelIdsEnd_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKQueryChannelRange this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int32_t ret_val = QueryChannelRange_end_blocknum(&this_arg_conv);
return ret_val;
}
LDKQueryChannelRange obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = QueryChannelRange_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKReplyChannelRange obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ReplyChannelRange_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKGossipTimestampFilter obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = GossipTimestampFilter_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKIgnoringMessageHandler this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
IgnoringMessageHandler_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKIgnoringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
*ret_ret = IgnoringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKIgnoringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRoutingMessageHandler* ret_ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
*ret_ret = IgnoringMessageHandler_as_RoutingMessageHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKIgnoringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCustomMessageReader* ret_ret = MALLOC(sizeof(LDKCustomMessageReader), "LDKCustomMessageReader");
*ret_ret = IgnoringMessageHandler_as_CustomMessageReader(&this_arg_conv);
return (uint64_t)ret_ret;
LDKIgnoringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCustomMessageHandler* ret_ret = MALLOC(sizeof(LDKCustomMessageHandler), "LDKCustomMessageHandler");
*ret_ret = IgnoringMessageHandler_as_CustomMessageHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKErroringMessageHandler this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ErroringMessageHandler_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKErroringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
*ret_ret = ErroringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKErroringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelMessageHandler* ret_ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
*ret_ret = ErroringMessageHandler_as_ChannelMessageHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKMessageHandler this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
MessageHandler_free(this_obj_conv);
}
LDKMessageHandler this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)MessageHandler_get_chan_handler(&this_ptr_conv)) | 1;
return ret_ret;
LDKMessageHandler this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKChannelMessageHandler val_conv = *(LDKChannelMessageHandler*)(val_ptr);
LDKMessageHandler this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)MessageHandler_get_route_handler(&this_ptr_conv)) | 1;
return ret_ret;
LDKMessageHandler this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKRoutingMessageHandler val_conv = *(LDKRoutingMessageHandler*)(val_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg) {
+ LDKSocketDescriptor* ret_ret = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
+ *ret_ret = SocketDescriptor_clone(arg);
+ return (uint64_t)ret_ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SocketDescriptor_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ void* arg_ptr = (void*)(((uint64_t)arg) & ~1);
+ if (!(arg & 1)) { CHECK_ACCESS(arg_ptr); }
+ LDKSocketDescriptor* arg_conv = (LDKSocketDescriptor*)arg_ptr;
+ int64_t ret_val = SocketDescriptor_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SocketDescriptor_1clone(JNIEnv *env, jclass clz, int64_t orig) {
void* orig_ptr = (void*)(((uint64_t)orig) & ~1);
if (!(orig & 1)) { CHECK_ACCESS(orig_ptr); }
LDKPeerHandleError this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
PeerHandleError_free(this_obj_conv);
}
LDKPeerHandleError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = PeerHandleError_get_no_connection_possible(&this_ptr_conv);
return ret_val;
}
LDKPeerHandleError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
PeerHandleError_set_no_connection_possible(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg) {
+ LDKPeerHandleError ret_var = PeerHandleError_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PeerHandleError_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKPeerHandleError arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = PeerHandleError_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PeerHandleError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKPeerHandleError orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPeerHandleError ret_var = PeerHandleError_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPeerManager this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
PeerManager_free(this_obj_conv);
}
LDKMessageHandler message_handler_conv;
message_handler_conv.inner = (void*)(message_handler & (~1));
message_handler_conv.is_owned = (message_handler & 1) || (message_handler == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(message_handler_conv);
// Warning: we need a move here but no clone is available for LDKMessageHandler
LDKSecretKey our_node_secret_ref;
CHECK((*env)->GetArrayLength(env, our_node_secret) == 32);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_PublicKeyZ ret_var = PeerManager_get_peer_node_ids(&this_arg_conv);
jobjectArray ret_arr = NULL;
ret_arr = (*env)->NewObjectArray(env, ret_var.datalen, arr_of_B_clz, NULL);
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPublicKey their_node_id_ref;
CHECK((*env)->GetArrayLength(env, their_node_id) == 33);
(*env)->GetByteArrayRegion(env, their_node_id, 0, 33, their_node_id_ref.compressed_form);
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* descriptor_ptr = (void*)(((uint64_t)descriptor) & ~1);
CHECK_ACCESS(descriptor_ptr);
LDKSocketDescriptor descriptor_conv = *(LDKSocketDescriptor*)(descriptor_ptr);
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* descriptor_ptr = (void*)(((uint64_t)descriptor) & ~1);
if (!(descriptor & 1)) { CHECK_ACCESS(descriptor_ptr); }
LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)descriptor_ptr;
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* peer_descriptor_ptr = (void*)(((uint64_t)peer_descriptor) & ~1);
if (!(peer_descriptor & 1)) { CHECK_ACCESS(peer_descriptor_ptr); }
LDKSocketDescriptor* peer_descriptor_conv = (LDKSocketDescriptor*)peer_descriptor_ptr;
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
PeerManager_process_events(&this_arg_conv);
}
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* descriptor_ptr = (void*)(((uint64_t)descriptor) & ~1);
if (!(descriptor & 1)) { CHECK_ACCESS(descriptor_ptr); }
LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)descriptor_ptr;
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPublicKey node_id_ref;
CHECK((*env)->GetArrayLength(env, node_id) == 33);
(*env)->GetByteArrayRegion(env, node_id, 0, 33, node_id_ref.compressed_form);
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
PeerManager_disconnect_all_peers(&this_arg_conv);
}
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
PeerManager_timer_tick_occurred(&this_arg_conv);
}
LDKOutPoint funding_outpoint_conv;
funding_outpoint_conv.inner = (void*)(funding_outpoint & (~1));
funding_outpoint_conv.is_owned = (funding_outpoint & 1) || (funding_outpoint == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
LDKTransaction ret_var = build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script_ref, to_counterparty_script_ref, funding_outpoint_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
LDKTxCreationKeys this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
TxCreationKeys_free(this_obj_conv);
}
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, TxCreationKeys_get_per_commitment_point(&this_ptr_conv).compressed_form);
return ret_arr;
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, TxCreationKeys_get_revocation_key(&this_ptr_conv).compressed_form);
return ret_arr;
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, TxCreationKeys_get_broadcaster_htlc_key(&this_ptr_conv).compressed_form);
return ret_arr;
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, TxCreationKeys_get_countersignatory_htlc_key(&this_ptr_conv).compressed_form);
return ret_arr;
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, TxCreationKeys_get_broadcaster_delayed_payment_key(&this_ptr_conv).compressed_form);
return ret_arr;
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg) {
+ LDKTxCreationKeys ret_var = TxCreationKeys_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKTxCreationKeys arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = TxCreationKeys_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKTxCreationKeys orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKTxCreationKeys ret_var = TxCreationKeys_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKTxCreationKeys obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = TxCreationKeys_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKChannelPublicKeys this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelPublicKeys_free(this_obj_conv);
}
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelPublicKeys_get_funding_pubkey(&this_ptr_conv).compressed_form);
return ret_arr;
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelPublicKeys_get_revocation_basepoint(&this_ptr_conv).compressed_form);
return ret_arr;
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelPublicKeys_get_payment_point(&this_ptr_conv).compressed_form);
return ret_arr;
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelPublicKeys_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form);
return ret_arr;
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ChannelPublicKeys_get_htlc_basepoint(&this_ptr_conv).compressed_form);
return ret_arr;
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg) {
+ LDKChannelPublicKeys ret_var = ChannelPublicKeys_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelPublicKeys arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelPublicKeys_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelPublicKeys orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelPublicKeys ret_var = ChannelPublicKeys_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelPublicKeys obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelPublicKeys_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKChannelPublicKeys broadcaster_keys_conv;
broadcaster_keys_conv.inner = (void*)(broadcaster_keys & (~1));
broadcaster_keys_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(broadcaster_keys_conv);
LDKChannelPublicKeys countersignatory_keys_conv;
countersignatory_keys_conv.inner = (void*)(countersignatory_keys & (~1));
countersignatory_keys_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(countersignatory_keys_conv);
LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
*ret_conv = TxCreationKeys_from_channel_static_keys(per_commitment_point_ref, &broadcaster_keys_conv, &countersignatory_keys_conv);
return (uint64_t)ret_conv;
LDKHTLCOutputInCommitment this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
HTLCOutputInCommitment_free(this_obj_conv);
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = HTLCOutputInCommitment_get_offered(&this_ptr_conv);
return ret_val;
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
HTLCOutputInCommitment_set_offered(&this_ptr_conv, val);
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = HTLCOutputInCommitment_get_amount_msat(&this_ptr_conv);
return ret_val;
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
HTLCOutputInCommitment_set_amount_msat(&this_ptr_conv, val);
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = HTLCOutputInCommitment_get_cltv_expiry(&this_ptr_conv);
return ret_val;
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
HTLCOutputInCommitment_set_cltv_expiry(&this_ptr_conv, val);
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *HTLCOutputInCommitment_get_payment_hash(&this_ptr_conv));
return ret_arr;
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
*ret_copy = HTLCOutputInCommitment_get_transaction_output_index(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg) {
+ LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKHTLCOutputInCommitment arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = HTLCOutputInCommitment_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKHTLCOutputInCommitment orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKHTLCOutputInCommitment obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = HTLCOutputInCommitment_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKHTLCOutputInCommitment htlc_conv;
htlc_conv.inner = (void*)(htlc & (~1));
htlc_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
LDKTxCreationKeys keys_conv;
keys_conv.inner = (void*)(keys & (~1));
keys_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(keys_conv);
LDKCVec_u8Z ret_var = get_htlc_redeemscript(&htlc_conv, &keys_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKHTLCOutputInCommitment htlc_conv;
htlc_conv.inner = (void*)(htlc & (~1));
htlc_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
LDKPublicKey broadcaster_delayed_payment_key_ref;
CHECK((*env)->GetArrayLength(env, broadcaster_delayed_payment_key) == 33);
(*env)->GetByteArrayRegion(env, broadcaster_delayed_payment_key, 0, 33, broadcaster_delayed_payment_key_ref.compressed_form);
LDKChannelTransactionParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelTransactionParameters_free(this_obj_conv);
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelPublicKeys ret_var = ChannelTransactionParameters_get_holder_pubkeys(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelPublicKeys val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelPublicKeys_clone(&val_conv);
ChannelTransactionParameters_set_holder_pubkeys(&this_ptr_conv, val_conv);
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = ChannelTransactionParameters_get_holder_selected_contest_delay(&this_ptr_conv);
return ret_val;
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelTransactionParameters_set_holder_selected_contest_delay(&this_ptr_conv, val);
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelTransactionParameters_get_is_outbound_from_holder(&this_ptr_conv);
return ret_val;
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelTransactionParameters_set_is_outbound_from_holder(&this_ptr_conv, val);
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCounterpartyChannelTransactionParameters ret_var = ChannelTransactionParameters_get_counterparty_parameters(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCounterpartyChannelTransactionParameters val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = CounterpartyChannelTransactionParameters_clone(&val_conv);
ChannelTransactionParameters_set_counterparty_parameters(&this_ptr_conv, val_conv);
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint ret_var = ChannelTransactionParameters_get_funding_outpoint(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = OutPoint_clone(&val_conv);
ChannelTransactionParameters_set_funding_outpoint(&this_ptr_conv, val_conv);
}
LDKChannelPublicKeys holder_pubkeys_arg_conv;
holder_pubkeys_arg_conv.inner = (void*)(holder_pubkeys_arg & (~1));
holder_pubkeys_arg_conv.is_owned = (holder_pubkeys_arg & 1) || (holder_pubkeys_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_pubkeys_arg_conv);
holder_pubkeys_arg_conv = ChannelPublicKeys_clone(&holder_pubkeys_arg_conv);
LDKCounterpartyChannelTransactionParameters counterparty_parameters_arg_conv;
counterparty_parameters_arg_conv.inner = (void*)(counterparty_parameters_arg & (~1));
counterparty_parameters_arg_conv.is_owned = (counterparty_parameters_arg & 1) || (counterparty_parameters_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(counterparty_parameters_arg_conv);
counterparty_parameters_arg_conv = CounterpartyChannelTransactionParameters_clone(&counterparty_parameters_arg_conv);
LDKOutPoint funding_outpoint_arg_conv;
funding_outpoint_arg_conv.inner = (void*)(funding_outpoint_arg & (~1));
funding_outpoint_arg_conv.is_owned = (funding_outpoint_arg & 1) || (funding_outpoint_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_arg_conv);
funding_outpoint_arg_conv = OutPoint_clone(&funding_outpoint_arg_conv);
LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_new(holder_pubkeys_arg_conv, holder_selected_contest_delay_arg, is_outbound_from_holder_arg, counterparty_parameters_arg_conv, funding_outpoint_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg) {
+ LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelTransactionParameters arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelTransactionParameters_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelTransactionParameters orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCounterpartyChannelTransactionParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
CounterpartyChannelTransactionParameters_free(this_obj_conv);
}
LDKCounterpartyChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelPublicKeys ret_var = CounterpartyChannelTransactionParameters_get_pubkeys(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCounterpartyChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelPublicKeys val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelPublicKeys_clone(&val_conv);
CounterpartyChannelTransactionParameters_set_pubkeys(&this_ptr_conv, val_conv);
}
LDKCounterpartyChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = CounterpartyChannelTransactionParameters_get_selected_contest_delay(&this_ptr_conv);
return ret_val;
}
LDKCounterpartyChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
CounterpartyChannelTransactionParameters_set_selected_contest_delay(&this_ptr_conv, val);
}
LDKChannelPublicKeys pubkeys_arg_conv;
pubkeys_arg_conv.inner = (void*)(pubkeys_arg & (~1));
pubkeys_arg_conv.is_owned = (pubkeys_arg & 1) || (pubkeys_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_arg_conv);
pubkeys_arg_conv = ChannelPublicKeys_clone(&pubkeys_arg_conv);
LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_new(pubkeys_arg_conv, selected_contest_delay_arg);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg) {
+ LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCounterpartyChannelTransactionParameters arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = CounterpartyChannelTransactionParameters_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCounterpartyChannelTransactionParameters orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = ChannelTransactionParameters_is_populated(&this_arg_conv);
return ret_val;
}
LDKChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_holder_broadcastable(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_counterparty_broadcastable(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCounterpartyChannelTransactionParameters obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = CounterpartyChannelTransactionParameters_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKChannelTransactionParameters obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelTransactionParameters_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKDirectedChannelTransactionParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DirectedChannelTransactionParameters_free(this_obj_conv);
}
LDKDirectedChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_broadcaster_pubkeys(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDirectedChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_countersignatory_pubkeys(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDirectedChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int16_t ret_val = DirectedChannelTransactionParameters_contest_delay(&this_arg_conv);
return ret_val;
}
LDKDirectedChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = DirectedChannelTransactionParameters_is_outbound(&this_arg_conv);
return ret_val;
}
LDKDirectedChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKOutPoint ret_var = DirectedChannelTransactionParameters_funding_outpoint(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKHolderCommitmentTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
HolderCommitmentTransaction_free(this_obj_conv);
}
LDKHolderCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 64);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 64, HolderCommitmentTransaction_get_counterparty_sig(&this_ptr_conv).compact_form);
return ret_arr;
LDKHolderCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK((*env)->GetArrayLength(env, val) == 64);
(*env)->GetByteArrayRegion(env, val, 0, 64, val_ref.compact_form);
LDKHolderCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_SignatureZ val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
HolderCommitmentTransaction_set_counterparty_htlc_sigs(&this_ptr_conv, val_constr);
}
+static inline uint64_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg) {
+ LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HolderCommitmentTransaction_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKHolderCommitmentTransaction arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = HolderCommitmentTransaction_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_HolderCommitmentTransaction_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKHolderCommitmentTransaction orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKHolderCommitmentTransaction obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = HolderCommitmentTransaction_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKCommitmentTransaction commitment_tx_conv;
commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
commitment_tx_conv.is_owned = (commitment_tx & 1) || (commitment_tx == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
commitment_tx_conv = CommitmentTransaction_clone(&commitment_tx_conv);
LDKSignature counterparty_sig_ref;
CHECK((*env)->GetArrayLength(env, counterparty_sig) == 64);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKBuiltCommitmentTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
BuiltCommitmentTransaction_free(this_obj_conv);
}
LDKBuiltCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKTransaction ret_var = BuiltCommitmentTransaction_get_transaction(&this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKBuiltCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKTransaction val_ref;
val_ref.datalen = (*env)->GetArrayLength(env, val);
val_ref.data = MALLOC(val_ref.datalen, "LDKTransaction Bytes");
LDKBuiltCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *BuiltCommitmentTransaction_get_txid(&this_ptr_conv));
return ret_arr;
LDKBuiltCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg) {
+ LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKBuiltCommitmentTransaction arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = BuiltCommitmentTransaction_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKBuiltCommitmentTransaction orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKBuiltCommitmentTransaction obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = BuiltCommitmentTransaction_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKBuiltCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKu8slice funding_redeemscript_ref;
funding_redeemscript_ref.datalen = (*env)->GetArrayLength(env, funding_redeemscript);
funding_redeemscript_ref.data = (*env)->GetByteArrayElements (env, funding_redeemscript, NULL);
LDKBuiltCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char funding_key_arr[32];
CHECK((*env)->GetArrayLength(env, funding_key) == 32);
(*env)->GetByteArrayRegion(env, funding_key, 0, 32, funding_key_arr);
LDKClosingTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ClosingTransaction_free(this_obj_conv);
}
+static inline uint64_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg) {
+ LDKClosingTransaction ret_var = ClosingTransaction_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosingTransaction_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKClosingTransaction arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ClosingTransaction_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ClosingTransaction_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKClosingTransaction orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKClosingTransaction ret_var = ClosingTransaction_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = ClosingTransaction_hash(&o_conv);
return ret_val;
}
LDKOutPoint funding_outpoint_conv;
funding_outpoint_conv.inner = (void*)(funding_outpoint & (~1));
funding_outpoint_conv.is_owned = (funding_outpoint & 1) || (funding_outpoint == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
LDKClosingTransaction ret_var = ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script_ref, to_counterparty_script_ref, funding_outpoint_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTrustedClosingTransaction ret_var = ClosingTransaction_trust(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKOutPoint funding_outpoint_conv;
funding_outpoint_conv.inner = (void*)(funding_outpoint & (~1));
funding_outpoint_conv.is_owned = (funding_outpoint & 1) || (funding_outpoint == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
*ret_conv = ClosingTransaction_verify(&this_arg_conv, funding_outpoint_conv);
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = ClosingTransaction_to_holder_value_sat(&this_arg_conv);
return ret_val;
}
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = ClosingTransaction_to_counterparty_value_sat(&this_arg_conv);
return ret_val;
}
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKu8slice ret_var = ClosingTransaction_to_holder_script(&this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKu8slice ret_var = ClosingTransaction_to_counterparty_script(&this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKTrustedClosingTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
TrustedClosingTransaction_free(this_obj_conv);
}
LDKTrustedClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTransaction ret_var = TrustedClosingTransaction_built_transaction(&this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKTrustedClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKu8slice funding_redeemscript_ref;
funding_redeemscript_ref.datalen = (*env)->GetArrayLength(env, funding_redeemscript);
funding_redeemscript_ref.data = (*env)->GetByteArrayElements (env, funding_redeemscript, NULL);
LDKTrustedClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char funding_key_arr[32];
CHECK((*env)->GetArrayLength(env, funding_key) == 32);
(*env)->GetByteArrayRegion(env, funding_key, 0, 32, funding_key_arr);
LDKCommitmentTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
CommitmentTransaction_free(this_obj_conv);
}
+static inline uint64_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg) {
+ LDKCommitmentTransaction ret_var = CommitmentTransaction_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKCommitmentTransaction arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = CommitmentTransaction_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKCommitmentTransaction orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKCommitmentTransaction ret_var = CommitmentTransaction_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentTransaction obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = CommitmentTransaction_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = CommitmentTransaction_commitment_number(&this_arg_conv);
return ret_val;
}
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = CommitmentTransaction_to_broadcaster_value_sat(&this_arg_conv);
return ret_val;
}
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = CommitmentTransaction_to_countersignatory_value_sat(&this_arg_conv);
return ret_val;
}
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int32_t ret_val = CommitmentTransaction_feerate_per_kw(&this_arg_conv);
return ret_val;
}
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTrustedCommitmentTransaction ret_var = CommitmentTransaction_trust(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKDirectedChannelTransactionParameters channel_parameters_conv;
channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
channel_parameters_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
LDKChannelPublicKeys broadcaster_keys_conv;
broadcaster_keys_conv.inner = (void*)(broadcaster_keys & (~1));
broadcaster_keys_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(broadcaster_keys_conv);
LDKChannelPublicKeys countersignatory_keys_conv;
countersignatory_keys_conv.inner = (void*)(countersignatory_keys & (~1));
countersignatory_keys_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(countersignatory_keys_conv);
LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
*ret_conv = CommitmentTransaction_verify(&this_arg_conv, &channel_parameters_conv, &broadcaster_keys_conv, &countersignatory_keys_conv);
return (uint64_t)ret_conv;
LDKTrustedCommitmentTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
TrustedCommitmentTransaction_free(this_obj_conv);
}
LDKTrustedCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, TrustedCommitmentTransaction_txid(&this_arg_conv).data);
return ret_arr;
LDKTrustedCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKBuiltCommitmentTransaction ret_var = TrustedCommitmentTransaction_built_transaction(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKTrustedCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTxCreationKeys ret_var = TrustedCommitmentTransaction_keys(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKTrustedCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char htlc_base_key_arr[32];
CHECK((*env)->GetArrayLength(env, htlc_base_key) == 32);
(*env)->GetByteArrayRegion(env, htlc_base_key, 0, 32, htlc_base_key_arr);
LDKDirectedChannelTransactionParameters channel_parameters_conv;
channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
channel_parameters_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
*ret_conv = TrustedCommitmentTransaction_get_htlc_sigs(&this_arg_conv, htlc_base_key_ref, &channel_parameters_conv);
return (uint64_t)ret_conv;
LDKInitFeatures a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKInitFeatures b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = InitFeatures_eq(&a_conv, &b_conv);
return ret_val;
}
LDKNodeFeatures a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKNodeFeatures b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = NodeFeatures_eq(&a_conv, &b_conv);
return ret_val;
}
LDKChannelFeatures a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKChannelFeatures b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = ChannelFeatures_eq(&a_conv, &b_conv);
return ret_val;
}
LDKInvoiceFeatures a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKInvoiceFeatures b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = InvoiceFeatures_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg) {
+ LDKInitFeatures ret_var = InitFeatures_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InitFeatures_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKInitFeatures arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = InitFeatures_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InitFeatures_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKInitFeatures orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInitFeatures ret_var = InitFeatures_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg) {
+ LDKNodeFeatures ret_var = NodeFeatures_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKNodeFeatures arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NodeFeatures_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKNodeFeatures orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNodeFeatures ret_var = NodeFeatures_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg) {
+ LDKChannelFeatures ret_var = ChannelFeatures_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelFeatures_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelFeatures arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelFeatures_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelFeatures_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelFeatures orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelFeatures ret_var = ChannelFeatures_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg) {
+ LDKInvoiceFeatures ret_var = InvoiceFeatures_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InvoiceFeatures_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKInvoiceFeatures arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = InvoiceFeatures_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InvoiceFeatures_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKInvoiceFeatures orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInvoiceFeatures ret_var = InvoiceFeatures_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInitFeatures this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InitFeatures_free(this_obj_conv);
}
LDKNodeFeatures this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NodeFeatures_free(this_obj_conv);
}
LDKChannelFeatures this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelFeatures_free(this_obj_conv);
}
LDKInvoiceFeatures this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InvoiceFeatures_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInitFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = InitFeatures_requires_unknown_bits(&this_arg_conv);
return ret_val;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = NodeFeatures_requires_unknown_bits(&this_arg_conv);
return ret_val;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = ChannelFeatures_requires_unknown_bits(&this_arg_conv);
return ret_val;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvoiceFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = InvoiceFeatures_requires_unknown_bits(&this_arg_conv);
return ret_val;
}
LDKInitFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = InitFeatures_supports_payment_secret(&this_arg_conv);
return ret_val;
}
LDKNodeFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = NodeFeatures_supports_payment_secret(&this_arg_conv);
return ret_val;
}
LDKInvoiceFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = InvoiceFeatures_supports_payment_secret(&this_arg_conv);
return ret_val;
}
LDKInitFeatures obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = InitFeatures_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKNodeFeatures obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NodeFeatures_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKChannelFeatures obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelFeatures_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKInvoiceFeatures obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = InvoiceFeatures_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKShutdownScript this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ShutdownScript_free(this_obj_conv);
}
+static inline uint64_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg) {
+ LDKShutdownScript ret_var = ShutdownScript_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ShutdownScript_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKShutdownScript arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ShutdownScript_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ShutdownScript_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKShutdownScript orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKShutdownScript ret_var = ShutdownScript_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvalidShutdownScript this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InvalidShutdownScript_free(this_obj_conv);
}
LDKInvalidShutdownScript this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKu8slice ret_var = InvalidShutdownScript_get_script(&this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKInvalidShutdownScript this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u8Z val_ref;
val_ref.datalen = (*env)->GetArrayLength(env, val);
val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg) {
+ LDKInvalidShutdownScript ret_var = InvalidShutdownScript_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InvalidShutdownScript_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKInvalidShutdownScript arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = InvalidShutdownScript_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InvalidShutdownScript_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKInvalidShutdownScript orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInvalidShutdownScript ret_var = InvalidShutdownScript_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKShutdownScript obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ShutdownScript_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKShutdownScript this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
this_arg_conv = ShutdownScript_clone(&this_arg_conv);
LDKCVec_u8Z ret_var = ShutdownScript_into_inner(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
LDKShutdownScript this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, ShutdownScript_as_legacy_pubkey(&this_arg_conv).compressed_form);
return ret_arr;
LDKShutdownScript this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInitFeatures features_conv;
features_conv.inner = (void*)(features & (~1));
features_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_conv);
jboolean ret_val = ShutdownScript_is_compatible(&this_arg_conv, &features_conv);
return ret_val;
}
CustomMessageReader_free(this_ptr_conv);
}
+static inline uint64_t Type_clone_ptr(LDKType *NONNULL_PTR arg) {
+ LDKType* ret_ret = MALLOC(sizeof(LDKType), "LDKType");
+ *ret_ret = Type_clone(arg);
+ return (uint64_t)ret_ret;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Type_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ void* arg_ptr = (void*)(((uint64_t)arg) & ~1);
+ if (!(arg & 1)) { CHECK_ACCESS(arg_ptr); }
+ LDKType* arg_conv = (LDKType*)arg_ptr;
+ int64_t ret_val = Type_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Type_1clone(JNIEnv *env, jclass clz, int64_t orig) {
void* orig_ptr = (void*)(((uint64_t)orig) & ~1);
if (!(orig & 1)) { CHECK_ACCESS(orig_ptr); }
LDKLockableScore this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
LockableScore_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKLockableScore obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = LockableScore_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKNodeId this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NodeId_free(this_obj_conv);
}
+static inline uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg) {
+ LDKNodeId ret_var = NodeId_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeId_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKNodeId arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NodeId_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeId_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKNodeId orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNodeId ret_var = NodeId_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeId this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKu8slice ret_var = NodeId_as_slice(&this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKNodeId o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = NodeId_hash(&o_conv);
return ret_val;
}
LDKNodeId obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NodeId_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKNetworkGraph this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NetworkGraph_free(this_obj_conv);
}
+static inline uint64_t NetworkGraph_clone_ptr(LDKNetworkGraph *NONNULL_PTR arg) {
+ LDKNetworkGraph ret_var = NetworkGraph_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKNetworkGraph arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NetworkGraph_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKNetworkGraph orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNetworkGraph ret_var = NetworkGraph_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKReadOnlyNetworkGraph this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ReadOnlyNetworkGraph_free(this_obj_conv);
}
NetworkUpdate_free(this_ptr_conv);
}
+static inline uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg) {
+ LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
+ *ret_copy = NetworkUpdate_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkUpdate_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKNetworkUpdate* arg_conv = (LDKNetworkUpdate*)arg;
+ int64_t ret_val = NetworkUpdate_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkUpdate_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKNetworkUpdate* orig_conv = (LDKNetworkUpdate*)orig;
LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ChannelUpdate_clone(&msg_conv);
LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
*ret_copy = NetworkUpdate_channel_update_message(msg_conv);
return ret_arr;
}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetworkUpdate_1read(JNIEnv *env, jclass clz, int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = (*env)->GetArrayLength(env, ser);
+ ser_ref.data = (*env)->GetByteArrayElements (env, ser, NULL);
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = NetworkUpdate_read(ser_ref);
+ (*env)->ReleaseByteArrayElements(env, ser, (int8_t*)ser_ref.data, 0);
+ return (uint64_t)ret_conv;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NetGraphMsgHandler_1as_1EventHandler(JNIEnv *env, jclass clz, int64_t this_arg) {
LDKNetGraphMsgHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKEventHandler* ret_ret = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
*ret_ret = NetGraphMsgHandler_as_EventHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKNetGraphMsgHandler this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NetGraphMsgHandler_free(this_obj_conv);
}
LDKNetworkGraph network_graph_conv;
network_graph_conv.inner = (void*)(network_graph & (~1));
network_graph_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
void* chain_access_ptr = (void*)(((uint64_t)chain_access) & ~1);
CHECK_ACCESS(chain_access_ptr);
LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNetGraphMsgHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* chain_access_ptr = (void*)(((uint64_t)chain_access) & ~1);
CHECK_ACCESS(chain_access_ptr);
LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
LDKNetGraphMsgHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRoutingMessageHandler* ret_ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
*ret_ret = NetGraphMsgHandler_as_RoutingMessageHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKNetGraphMsgHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
*ret_ret = NetGraphMsgHandler_as_MessageSendEventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKDirectionalChannelInfo this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DirectionalChannelInfo_free(this_obj_conv);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = DirectionalChannelInfo_get_last_update(&this_ptr_conv);
return ret_val;
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DirectionalChannelInfo_set_last_update(&this_ptr_conv, val);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = DirectionalChannelInfo_get_enabled(&this_ptr_conv);
return ret_val;
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DirectionalChannelInfo_set_enabled(&this_ptr_conv, val);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = DirectionalChannelInfo_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DirectionalChannelInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = DirectionalChannelInfo_get_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DirectionalChannelInfo_set_htlc_minimum_msat(&this_ptr_conv, val);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = DirectionalChannelInfo_get_htlc_maximum_msat(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees ret_var = DirectionalChannelInfo_get_fees(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = RoutingFees_clone(&val_conv);
DirectionalChannelInfo_set_fees(&this_ptr_conv, val_conv);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelUpdate ret_var = DirectionalChannelInfo_get_last_update_message(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelUpdate val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelUpdate_clone(&val_conv);
DirectionalChannelInfo_set_last_update_message(&this_ptr_conv, val_conv);
}
LDKRoutingFees fees_arg_conv;
fees_arg_conv.inner = (void*)(fees_arg & (~1));
fees_arg_conv.is_owned = (fees_arg & 1) || (fees_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(fees_arg_conv);
fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
LDKChannelUpdate last_update_message_arg_conv;
last_update_message_arg_conv.inner = (void*)(last_update_message_arg & (~1));
last_update_message_arg_conv.is_owned = (last_update_message_arg & 1) || (last_update_message_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(last_update_message_arg_conv);
last_update_message_arg_conv = ChannelUpdate_clone(&last_update_message_arg_conv);
LDKDirectionalChannelInfo ret_var = DirectionalChannelInfo_new(last_update_arg, enabled_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg_conv, fees_arg_conv, last_update_message_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t DirectionalChannelInfo_clone_ptr(LDKDirectionalChannelInfo *NONNULL_PTR arg) {
+ LDKDirectionalChannelInfo ret_var = DirectionalChannelInfo_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKDirectionalChannelInfo arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = DirectionalChannelInfo_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKDirectionalChannelInfo orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKDirectionalChannelInfo ret_var = DirectionalChannelInfo_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDirectionalChannelInfo obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = DirectionalChannelInfo_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKChannelInfo this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelInfo_free(this_obj_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures ret_var = ChannelInfo_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelFeatures_clone(&val_conv);
ChannelInfo_set_features(&this_ptr_conv, val_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeId ret_var = ChannelInfo_get_node_one(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeId val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeId_clone(&val_conv);
ChannelInfo_set_node_one(&this_ptr_conv, val_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKDirectionalChannelInfo ret_var = ChannelInfo_get_one_to_two(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKDirectionalChannelInfo val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = DirectionalChannelInfo_clone(&val_conv);
ChannelInfo_set_one_to_two(&this_ptr_conv, val_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeId ret_var = ChannelInfo_get_node_two(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeId val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeId_clone(&val_conv);
ChannelInfo_set_node_two(&this_ptr_conv, val_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKDirectionalChannelInfo ret_var = ChannelInfo_get_two_to_one(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKDirectionalChannelInfo val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = DirectionalChannelInfo_clone(&val_conv);
ChannelInfo_set_two_to_one(&this_ptr_conv, val_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = ChannelInfo_get_capacity_sats(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelAnnouncement ret_var = ChannelInfo_get_announcement_message(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelAnnouncement val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelAnnouncement_clone(&val_conv);
ChannelInfo_set_announcement_message(&this_ptr_conv, val_conv);
}
LDKChannelFeatures features_arg_conv;
features_arg_conv.inner = (void*)(features_arg & (~1));
features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
features_arg_conv = ChannelFeatures_clone(&features_arg_conv);
LDKNodeId node_one_arg_conv;
node_one_arg_conv.inner = (void*)(node_one_arg & (~1));
node_one_arg_conv.is_owned = (node_one_arg & 1) || (node_one_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(node_one_arg_conv);
node_one_arg_conv = NodeId_clone(&node_one_arg_conv);
LDKDirectionalChannelInfo one_to_two_arg_conv;
one_to_two_arg_conv.inner = (void*)(one_to_two_arg & (~1));
one_to_two_arg_conv.is_owned = (one_to_two_arg & 1) || (one_to_two_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(one_to_two_arg_conv);
one_to_two_arg_conv = DirectionalChannelInfo_clone(&one_to_two_arg_conv);
LDKNodeId node_two_arg_conv;
node_two_arg_conv.inner = (void*)(node_two_arg & (~1));
node_two_arg_conv.is_owned = (node_two_arg & 1) || (node_two_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(node_two_arg_conv);
node_two_arg_conv = NodeId_clone(&node_two_arg_conv);
LDKDirectionalChannelInfo two_to_one_arg_conv;
two_to_one_arg_conv.inner = (void*)(two_to_one_arg & (~1));
two_to_one_arg_conv.is_owned = (two_to_one_arg & 1) || (two_to_one_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(two_to_one_arg_conv);
two_to_one_arg_conv = DirectionalChannelInfo_clone(&two_to_one_arg_conv);
void* capacity_sats_arg_ptr = (void*)(((uint64_t)capacity_sats_arg) & ~1);
CHECK_ACCESS(capacity_sats_arg_ptr);
LDKChannelAnnouncement announcement_message_arg_conv;
announcement_message_arg_conv.inner = (void*)(announcement_message_arg & (~1));
announcement_message_arg_conv.is_owned = (announcement_message_arg & 1) || (announcement_message_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(announcement_message_arg_conv);
announcement_message_arg_conv = ChannelAnnouncement_clone(&announcement_message_arg_conv);
LDKChannelInfo ret_var = ChannelInfo_new(features_arg_conv, node_one_arg_conv, one_to_two_arg_conv, node_two_arg_conv, two_to_one_arg_conv, capacity_sats_arg_conv, announcement_message_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg) {
+ LDKChannelInfo ret_var = ChannelInfo_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKChannelInfo arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelInfo_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKChannelInfo orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelInfo ret_var = ChannelInfo_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelInfo_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKRoutingFees this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RoutingFees_free(this_obj_conv);
}
LDKRoutingFees this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = RoutingFees_get_base_msat(&this_ptr_conv);
return ret_val;
}
LDKRoutingFees this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RoutingFees_set_base_msat(&this_ptr_conv, val);
}
LDKRoutingFees this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = RoutingFees_get_proportional_millionths(&this_ptr_conv);
return ret_val;
}
LDKRoutingFees this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RoutingFees_set_proportional_millionths(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRoutingFees a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRoutingFees b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RoutingFees_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg) {
+ LDKRoutingFees ret_var = RoutingFees_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingFees_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKRoutingFees arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RoutingFees_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RoutingFees_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKRoutingFees orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRoutingFees ret_var = RoutingFees_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRoutingFees o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = RoutingFees_hash(&o_conv);
return ret_val;
}
LDKRoutingFees obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RoutingFees_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKNodeAnnouncementInfo this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NodeAnnouncementInfo_free(this_obj_conv);
}
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures ret_var = NodeAnnouncementInfo_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeFeatures_clone(&val_conv);
NodeAnnouncementInfo_set_features(&this_ptr_conv, val_conv);
}
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = NodeAnnouncementInfo_get_last_update(&this_ptr_conv);
return ret_val;
}
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
NodeAnnouncementInfo_set_last_update(&this_ptr_conv, val);
}
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 3);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 3, *NodeAnnouncementInfo_get_rgb(&this_ptr_conv));
return ret_arr;
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThreeBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 3);
(*env)->GetByteArrayRegion(env, val, 0, 3, val_ref.data);
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *NodeAnnouncementInfo_get_alias(&this_ptr_conv));
return ret_arr;
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK((*env)->GetArrayLength(env, val) == 32);
(*env)->GetByteArrayRegion(env, val, 0, 32, val_ref.data);
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_NetAddressZ val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeAnnouncement ret_var = NodeAnnouncementInfo_get_announcement_message(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeAnnouncement val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeAnnouncement_clone(&val_conv);
NodeAnnouncementInfo_set_announcement_message(&this_ptr_conv, val_conv);
}
LDKNodeFeatures features_arg_conv;
features_arg_conv.inner = (void*)(features_arg & (~1));
features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
features_arg_conv = NodeFeatures_clone(&features_arg_conv);
LDKThreeBytes rgb_arg_ref;
CHECK((*env)->GetArrayLength(env, rgb_arg) == 3);
LDKNodeAnnouncement announcement_message_arg_conv;
announcement_message_arg_conv.inner = (void*)(announcement_message_arg & (~1));
announcement_message_arg_conv.is_owned = (announcement_message_arg & 1) || (announcement_message_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(announcement_message_arg_conv);
announcement_message_arg_conv = NodeAnnouncement_clone(&announcement_message_arg_conv);
LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_new(features_arg_conv, last_update_arg, rgb_arg_ref, alias_arg_ref, addresses_arg_constr, announcement_message_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg) {
+ LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKNodeAnnouncementInfo arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NodeAnnouncementInfo_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKNodeAnnouncementInfo orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeAnnouncementInfo obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NodeAnnouncementInfo_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKNodeInfo this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NodeInfo_free(this_obj_conv);
}
LDKNodeInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u64Z val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
LDKNodeInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees ret_var = NodeInfo_get_lowest_inbound_channel_fees(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = RoutingFees_clone(&val_conv);
NodeInfo_set_lowest_inbound_channel_fees(&this_ptr_conv, val_conv);
}
LDKNodeInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeAnnouncementInfo ret_var = NodeInfo_get_announcement_info(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeAnnouncementInfo val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeAnnouncementInfo_clone(&val_conv);
NodeInfo_set_announcement_info(&this_ptr_conv, val_conv);
}
LDKRoutingFees lowest_inbound_channel_fees_arg_conv;
lowest_inbound_channel_fees_arg_conv.inner = (void*)(lowest_inbound_channel_fees_arg & (~1));
lowest_inbound_channel_fees_arg_conv.is_owned = (lowest_inbound_channel_fees_arg & 1) || (lowest_inbound_channel_fees_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(lowest_inbound_channel_fees_arg_conv);
lowest_inbound_channel_fees_arg_conv = RoutingFees_clone(&lowest_inbound_channel_fees_arg_conv);
LDKNodeAnnouncementInfo announcement_info_arg_conv;
announcement_info_arg_conv.inner = (void*)(announcement_info_arg & (~1));
announcement_info_arg_conv.is_owned = (announcement_info_arg & 1) || (announcement_info_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(announcement_info_arg_conv);
announcement_info_arg_conv = NodeAnnouncementInfo_clone(&announcement_info_arg_conv);
LDKNodeInfo ret_var = NodeInfo_new(channels_arg_constr, lowest_inbound_channel_fees_arg_conv, announcement_info_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg) {
+ LDKNodeInfo ret_var = NodeInfo_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeInfo_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKNodeInfo arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NodeInfo_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_NodeInfo_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKNodeInfo orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNodeInfo ret_var = NodeInfo_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeInfo obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NodeInfo_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKNetworkGraph obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NetworkGraph_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKReadOnlyNetworkGraph ret_var = NetworkGraph_read_only(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKNodeAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = NetworkGraph_update_node_from_announcement(&this_arg_conv, &msg_conv);
return (uint64_t)ret_conv;
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKUnsignedNodeAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = NetworkGraph_update_node_from_unsigned_announcement(&this_arg_conv, &msg_conv);
return (uint64_t)ret_conv;
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
void* chain_access_ptr = (void*)(((uint64_t)chain_access) & ~1);
CHECK_ACCESS(chain_access_ptr);
LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKUnsignedChannelAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
void* chain_access_ptr = (void*)(((uint64_t)chain_access) & ~1);
CHECK_ACCESS(chain_access_ptr);
LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
NetworkGraph_close_channel_from_update(&this_arg_conv, short_channel_id, is_permanent);
}
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPublicKey _node_id_ref;
CHECK((*env)->GetArrayLength(env, _node_id) == 33);
(*env)->GetByteArrayRegion(env, _node_id, 0, 33, _node_id_ref.compressed_form);
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = NetworkGraph_update_channel(&this_arg_conv, &msg_conv);
return (uint64_t)ret_conv;
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKUnsignedChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = NetworkGraph_update_channel_unsigned(&this_arg_conv, &msg_conv);
return (uint64_t)ret_conv;
LDKReadOnlyNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPublicKey pubkey_ref;
CHECK((*env)->GetArrayLength(env, pubkey) == 33);
(*env)->GetByteArrayRegion(env, pubkey, 0, 33, pubkey_ref.compressed_form);
LDKRouteHop this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RouteHop_free(this_obj_conv);
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, RouteHop_get_pubkey(&this_ptr_conv).compressed_form);
return ret_arr;
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures ret_var = RouteHop_get_node_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeFeatures_clone(&val_conv);
RouteHop_set_node_features(&this_ptr_conv, val_conv);
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = RouteHop_get_short_channel_id(&this_ptr_conv);
return ret_val;
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteHop_set_short_channel_id(&this_ptr_conv, val);
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures ret_var = RouteHop_get_channel_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelFeatures_clone(&val_conv);
RouteHop_set_channel_features(&this_ptr_conv, val_conv);
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = RouteHop_get_fee_msat(&this_ptr_conv);
return ret_val;
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteHop_set_fee_msat(&this_ptr_conv, val);
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = RouteHop_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteHop_set_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKNodeFeatures node_features_arg_conv;
node_features_arg_conv.inner = (void*)(node_features_arg & (~1));
node_features_arg_conv.is_owned = (node_features_arg & 1) || (node_features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(node_features_arg_conv);
node_features_arg_conv = NodeFeatures_clone(&node_features_arg_conv);
LDKChannelFeatures channel_features_arg_conv;
channel_features_arg_conv.inner = (void*)(channel_features_arg & (~1));
channel_features_arg_conv.is_owned = (channel_features_arg & 1) || (channel_features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_features_arg_conv);
channel_features_arg_conv = ChannelFeatures_clone(&channel_features_arg_conv);
LDKRouteHop ret_var = RouteHop_new(pubkey_arg_ref, node_features_arg_conv, short_channel_id_arg, channel_features_arg_conv, fee_msat_arg, cltv_expiry_delta_arg);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg) {
+ LDKRouteHop ret_var = RouteHop_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHop_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKRouteHop arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RouteHop_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHop_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKRouteHop orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRouteHop ret_var = RouteHop_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHop o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = RouteHop_hash(&o_conv);
return ret_val;
}
LDKRouteHop a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRouteHop b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RouteHop_eq(&a_conv, &b_conv);
return ret_val;
}
LDKRouteHop obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RouteHop_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKRoute this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Route_free(this_obj_conv);
}
LDKRoute this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_CVec_RouteHopZZ ret_var = Route_get_paths(&this_ptr_conv);
jobjectArray ret_arr = NULL;
ret_arr = (*env)->NewObjectArray(env, ret_var.datalen, arr_of_J_clz, NULL);
uint64_t ret_conv_12_conv_10_ref = 0;
CHECK((((uint64_t)ret_conv_12_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_12_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_12_conv_10_var);
ret_conv_12_conv_10_ref = (uint64_t)ret_conv_12_conv_10_var.inner;
if (ret_conv_12_conv_10_var.is_owned) {
ret_conv_12_conv_10_ref |= 1;
LDKRoute this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_CVec_RouteHopZZ val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
LDKRouteHop val_conv_12_conv_10_conv;
val_conv_12_conv_10_conv.inner = (void*)(val_conv_12_conv_10 & (~1));
val_conv_12_conv_10_conv.is_owned = (val_conv_12_conv_10 & 1) || (val_conv_12_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_12_conv_10_conv);
val_conv_12_conv_10_conv = RouteHop_clone(&val_conv_12_conv_10_conv);
val_conv_12_constr.data[k] = val_conv_12_conv_10_conv;
}
LDKRoute this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPayee ret_var = Route_get_payee(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRoute this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPayee val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = Payee_clone(&val_conv);
Route_set_payee(&this_ptr_conv, val_conv);
}
LDKRouteHop paths_arg_conv_12_conv_10_conv;
paths_arg_conv_12_conv_10_conv.inner = (void*)(paths_arg_conv_12_conv_10 & (~1));
paths_arg_conv_12_conv_10_conv.is_owned = (paths_arg_conv_12_conv_10 & 1) || (paths_arg_conv_12_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(paths_arg_conv_12_conv_10_conv);
paths_arg_conv_12_conv_10_conv = RouteHop_clone(&paths_arg_conv_12_conv_10_conv);
paths_arg_conv_12_constr.data[k] = paths_arg_conv_12_conv_10_conv;
}
LDKPayee payee_arg_conv;
payee_arg_conv.inner = (void*)(payee_arg & (~1));
payee_arg_conv.is_owned = (payee_arg & 1) || (payee_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(payee_arg_conv);
payee_arg_conv = Payee_clone(&payee_arg_conv);
LDKRoute ret_var = Route_new(paths_arg_constr, payee_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg) {
+ LDKRoute ret_var = Route_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Route_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKRoute arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Route_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Route_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKRoute orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRoute ret_var = Route_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRoute o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = Route_hash(&o_conv);
return ret_val;
}
LDKRoute a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRoute b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = Route_eq(&a_conv, &b_conv);
return ret_val;
}
LDKRoute this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = Route_get_total_fees(&this_arg_conv);
return ret_val;
}
LDKRoute this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = Route_get_total_amount(&this_arg_conv);
return ret_val;
}
LDKRoute obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Route_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKRouteParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RouteParameters_free(this_obj_conv);
}
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPayee ret_var = RouteParameters_get_payee(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPayee val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = Payee_clone(&val_conv);
RouteParameters_set_payee(&this_ptr_conv, val_conv);
}
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = RouteParameters_get_final_value_msat(&this_ptr_conv);
return ret_val;
}
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteParameters_set_final_value_msat(&this_ptr_conv, val);
}
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = RouteParameters_get_final_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteParameters_set_final_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKPayee payee_arg_conv;
payee_arg_conv.inner = (void*)(payee_arg & (~1));
payee_arg_conv.is_owned = (payee_arg & 1) || (payee_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(payee_arg_conv);
payee_arg_conv = Payee_clone(&payee_arg_conv);
LDKRouteParameters ret_var = RouteParameters_new(payee_arg_conv, final_value_msat_arg, final_cltv_expiry_delta_arg);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg) {
+ LDKRouteParameters ret_var = RouteParameters_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteParameters_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKRouteParameters arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RouteParameters_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteParameters_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKRouteParameters orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRouteParameters ret_var = RouteParameters_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteParameters obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RouteParameters_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKPayee this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Payee_free(this_obj_conv);
}
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, Payee_get_pubkey(&this_ptr_conv).compressed_form);
return ret_arr;
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInvoiceFeatures ret_var = Payee_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInvoiceFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = InvoiceFeatures_clone(&val_conv);
Payee_set_features(&this_ptr_conv, val_conv);
}
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_RouteHintZ ret_var = Payee_get_route_hints(&this_ptr_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_11_ref = 0;
CHECK((((uint64_t)ret_conv_11_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_11_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_11_var);
ret_conv_11_ref = (uint64_t)ret_conv_11_var.inner;
if (ret_conv_11_var.is_owned) {
ret_conv_11_ref |= 1;
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_RouteHintZ val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
LDKRouteHint val_conv_11_conv;
val_conv_11_conv.inner = (void*)(val_conv_11 & (~1));
val_conv_11_conv.is_owned = (val_conv_11 & 1) || (val_conv_11 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_11_conv);
val_conv_11_conv = RouteHint_clone(&val_conv_11_conv);
val_constr.data[l] = val_conv_11_conv;
}
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = Payee_get_expiry_time(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKInvoiceFeatures features_arg_conv;
features_arg_conv.inner = (void*)(features_arg & (~1));
features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
features_arg_conv = InvoiceFeatures_clone(&features_arg_conv);
LDKCVec_RouteHintZ route_hints_arg_constr;
route_hints_arg_constr.datalen = (*env)->GetArrayLength(env, route_hints_arg);
LDKRouteHint route_hints_arg_conv_11_conv;
route_hints_arg_conv_11_conv.inner = (void*)(route_hints_arg_conv_11 & (~1));
route_hints_arg_conv_11_conv.is_owned = (route_hints_arg_conv_11 & 1) || (route_hints_arg_conv_11 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_hints_arg_conv_11_conv);
route_hints_arg_conv_11_conv = RouteHint_clone(&route_hints_arg_conv_11_conv);
route_hints_arg_constr.data[l] = route_hints_arg_conv_11_conv;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Payee_clone_ptr(LDKPayee *NONNULL_PTR arg) {
+ LDKPayee ret_var = Payee_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Payee_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKPayee arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Payee_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Payee_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKPayee orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPayee ret_var = Payee_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPayee o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = Payee_hash(&o_conv);
return ret_val;
}
LDKPayee a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKPayee b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = Payee_eq(&a_conv, &b_conv);
return ret_val;
}
LDKPayee obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Payee_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHint this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RouteHint_free(this_obj_conv);
}
LDKRouteHint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_RouteHintHopZ ret_var = RouteHint_get_a(&this_ptr_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_14_ref = 0;
CHECK((((uint64_t)ret_conv_14_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_14_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
ret_conv_14_ref = (uint64_t)ret_conv_14_var.inner;
if (ret_conv_14_var.is_owned) {
ret_conv_14_ref |= 1;
LDKRouteHint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_RouteHintHopZ val_constr;
val_constr.datalen = (*env)->GetArrayLength(env, val);
if (val_constr.datalen > 0)
LDKRouteHintHop val_conv_14_conv;
val_conv_14_conv.inner = (void*)(val_conv_14 & (~1));
val_conv_14_conv.is_owned = (val_conv_14 & 1) || (val_conv_14 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_14_conv);
val_conv_14_conv = RouteHintHop_clone(&val_conv_14_conv);
val_constr.data[o] = val_conv_14_conv;
}
LDKRouteHintHop a_arg_conv_14_conv;
a_arg_conv_14_conv.inner = (void*)(a_arg_conv_14 & (~1));
a_arg_conv_14_conv.is_owned = (a_arg_conv_14 & 1) || (a_arg_conv_14 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_arg_conv_14_conv);
a_arg_conv_14_conv = RouteHintHop_clone(&a_arg_conv_14_conv);
a_arg_constr.data[o] = a_arg_conv_14_conv;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg) {
+ LDKRouteHint ret_var = RouteHint_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHint_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKRouteHint arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RouteHint_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHint_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKRouteHint orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRouteHint ret_var = RouteHint_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHint o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = RouteHint_hash(&o_conv);
return ret_val;
}
LDKRouteHint a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRouteHint b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RouteHint_eq(&a_conv, &b_conv);
return ret_val;
}
LDKRouteHint obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RouteHint_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKRouteHintHop this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RouteHintHop_free(this_obj_conv);
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, RouteHintHop_get_src_node_id(&this_ptr_conv).compressed_form);
return ret_arr;
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = RouteHintHop_get_short_channel_id(&this_ptr_conv);
return ret_val;
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteHintHop_set_short_channel_id(&this_ptr_conv, val);
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees ret_var = RouteHintHop_get_fees(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = RoutingFees_clone(&val_conv);
RouteHintHop_set_fees(&this_ptr_conv, val_conv);
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = RouteHintHop_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteHintHop_set_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = RouteHintHop_get_htlc_minimum_msat(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = RouteHintHop_get_htlc_maximum_msat(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKRoutingFees fees_arg_conv;
fees_arg_conv.inner = (void*)(fees_arg & (~1));
fees_arg_conv.is_owned = (fees_arg & 1) || (fees_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(fees_arg_conv);
fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
void* htlc_minimum_msat_arg_ptr = (void*)(((uint64_t)htlc_minimum_msat_arg) & ~1);
CHECK_ACCESS(htlc_minimum_msat_arg_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg) {
+ LDKRouteHintHop ret_var = RouteHintHop_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHintHop_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKRouteHintHop arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RouteHintHop_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RouteHintHop_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKRouteHintHop orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRouteHintHop ret_var = RouteHintHop_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHintHop o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = RouteHintHop_hash(&o_conv);
return ret_val;
}
LDKRouteHintHop a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRouteHintHop b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RouteHintHop_eq(&a_conv, &b_conv);
return ret_val;
}
LDKRouteHintHop obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RouteHintHop_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKRouteParameters params_conv;
params_conv.inner = (void*)(params & (~1));
params_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
LDKNetworkGraph network_conv;
network_conv.inner = (void*)(network & (~1));
network_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(network_conv);
LDKCVec_ChannelDetailsZ first_hops_constr;
LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL;
if (first_hops != NULL) {
LDKChannelDetails first_hops_conv_16_conv;
first_hops_conv_16_conv.inner = (void*)(first_hops_conv_16 & (~1));
first_hops_conv_16_conv.is_owned = (first_hops_conv_16 & 1) || (first_hops_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_conv);
first_hops_constr.data[q] = first_hops_conv_16_conv;
}
(*env)->ReleaseLongArrayElements(env, first_hops, first_hops_vals, 0);
LDKScorer this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Scorer_free(this_obj_conv);
}
LDKScoringParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ScoringParameters_free(this_obj_conv);
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ScoringParameters_get_base_penalty_msat(&this_ptr_conv);
return ret_val;
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ScoringParameters_set_base_penalty_msat(&this_ptr_conv, val);
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ScoringParameters_get_failure_penalty_msat(&this_ptr_conv);
return ret_val;
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ScoringParameters_set_failure_penalty_msat(&this_ptr_conv, val);
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ScoringParameters_get_failure_penalty_half_life(&this_ptr_conv);
return ret_val;
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ScoringParameters_set_failure_penalty_half_life(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKScoringParameters obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ScoringParameters_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKScoringParameters params_conv;
params_conv.inner = (void*)(params & (~1));
params_conv.is_owned = (params & 1) || (params == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
// Warning: we need a move here but no clone is available for LDKScoringParameters
LDKScorer ret_var = Scorer_new(params_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKScorer this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
*ret_ret = Scorer_as_Score(&this_arg_conv);
return (uint64_t)ret_ret;
LDKScorer obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Scorer_write(&obj_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, ret_var.datalen);
(*env)->SetByteArrayRegion(env, ret_arr, 0, ret_var.datalen, ret_var.data);
LDKFilesystemPersister this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
FilesystemPersister_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKFilesystemPersister this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKStr ret_str = FilesystemPersister_get_data_dir(&this_arg_conv);
jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
Str_free(ret_str);
LDKChannelManager manager_conv;
manager_conv.inner = (void*)(manager & (~1));
manager_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(manager_conv);
LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
*ret_conv = FilesystemPersister_persist_manager(data_dir_conv, &manager_conv);
return (uint64_t)ret_conv;
LDKFilesystemPersister this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* keys_manager_ptr = (void*)(((uint64_t)keys_manager) & ~1);
CHECK_ACCESS(keys_manager_ptr);
LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(keys_manager_ptr);
LDKFilesystemPersister this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPersist* ret_ret = MALLOC(sizeof(LDKPersist), "LDKPersist");
*ret_ret = FilesystemPersister_as_Persist(&this_arg_conv);
return (uint64_t)ret_ret;
LDKBackgroundProcessor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
BackgroundProcessor_free(this_obj_conv);
}
LDKChainMonitor chain_monitor_conv;
chain_monitor_conv.inner = (void*)(chain_monitor & (~1));
chain_monitor_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(chain_monitor_conv);
LDKChannelManager channel_manager_conv;
channel_manager_conv.inner = (void*)(channel_manager & (~1));
channel_manager_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_manager_conv);
LDKNetGraphMsgHandler net_graph_msg_handler_conv;
net_graph_msg_handler_conv.inner = (void*)(net_graph_msg_handler & (~1));
net_graph_msg_handler_conv.is_owned = (net_graph_msg_handler & 1) || (net_graph_msg_handler == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(net_graph_msg_handler_conv);
LDKPeerManager peer_manager_conv;
peer_manager_conv.inner = (void*)(peer_manager & (~1));
peer_manager_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(peer_manager_conv);
void* logger_ptr = (void*)(((uint64_t)logger) & ~1);
CHECK_ACCESS(logger_ptr);
LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKBackgroundProcessor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
// Warning: we need a move here but no clone is available for LDKBackgroundProcessor
LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
*ret_conv = BackgroundProcessor_join(this_arg_conv);
LDKBackgroundProcessor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
// Warning: we need a move here but no clone is available for LDKBackgroundProcessor
LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
*ret_conv = BackgroundProcessor_stop(this_arg_conv);
LDKInvoice this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Invoice_free(this_obj_conv);
}
LDKInvoice a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKInvoice b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = Invoice_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg) {
+ LDKInvoice ret_var = Invoice_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Invoice_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKInvoice arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Invoice_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Invoice_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKInvoice orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInvoice ret_var = Invoice_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKSignedRawInvoice this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
SignedRawInvoice_free(this_obj_conv);
}
LDKSignedRawInvoice a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKSignedRawInvoice b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = SignedRawInvoice_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg) {
+ LDKSignedRawInvoice ret_var = SignedRawInvoice_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SignedRawInvoice_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKSignedRawInvoice arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = SignedRawInvoice_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SignedRawInvoice_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKSignedRawInvoice orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKSignedRawInvoice ret_var = SignedRawInvoice_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RawInvoice_free(this_obj_conv);
}
LDKRawInvoice this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRawDataPart ret_var = RawInvoice_get_data(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRawDataPart val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = RawDataPart_clone(&val_conv);
RawInvoice_set_data(&this_ptr_conv, val_conv);
}
LDKRawInvoice a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRawInvoice b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RawInvoice_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg) {
+ LDKRawInvoice ret_var = RawInvoice_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RawInvoice_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKRawInvoice arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RawInvoice_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RawInvoice_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKRawInvoice orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRawInvoice ret_var = RawInvoice_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawDataPart this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RawDataPart_free(this_obj_conv);
}
LDKRawDataPart this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPositiveTimestamp ret_var = RawDataPart_get_timestamp(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawDataPart this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPositiveTimestamp val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = PositiveTimestamp_clone(&val_conv);
RawDataPart_set_timestamp(&this_ptr_conv, val_conv);
}
LDKRawDataPart a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRawDataPart b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RawDataPart_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg) {
+ LDKRawDataPart ret_var = RawDataPart_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RawDataPart_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKRawDataPart arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RawDataPart_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RawDataPart_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKRawDataPart orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRawDataPart ret_var = RawDataPart_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPositiveTimestamp this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
PositiveTimestamp_free(this_obj_conv);
}
LDKPositiveTimestamp a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKPositiveTimestamp b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = PositiveTimestamp_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg) {
+ LDKPositiveTimestamp ret_var = PositiveTimestamp_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PositiveTimestamp_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKPositiveTimestamp arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = PositiveTimestamp_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PositiveTimestamp_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKPositiveTimestamp orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPositiveTimestamp ret_var = PositiveTimestamp_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKSha256 this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Sha256_free(this_obj_conv);
}
+static inline uint64_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg) {
+ LDKSha256 ret_var = Sha256_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Sha256_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKSha256 arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Sha256_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Sha256_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKSha256 orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKSha256 ret_var = Sha256_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKSha256 o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = Sha256_hash(&o_conv);
return ret_val;
}
LDKSha256 a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKSha256 b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = Sha256_eq(&a_conv, &b_conv);
return ret_val;
}
LDKDescription this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Description_free(this_obj_conv);
}
+static inline uint64_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg) {
+ LDKDescription ret_var = Description_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Description_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKDescription arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Description_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Description_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKDescription orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKDescription ret_var = Description_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDescription o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = Description_hash(&o_conv);
return ret_val;
}
LDKDescription a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKDescription b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = Description_eq(&a_conv, &b_conv);
return ret_val;
}
LDKPayeePubKey this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
PayeePubKey_free(this_obj_conv);
}
LDKPayeePubKey this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, PayeePubKey_get_a(&this_ptr_conv).compressed_form);
return ret_arr;
LDKPayeePubKey this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK((*env)->GetArrayLength(env, val) == 33);
(*env)->GetByteArrayRegion(env, val, 0, 33, val_ref.compressed_form);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg) {
+ LDKPayeePubKey ret_var = PayeePubKey_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PayeePubKey_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKPayeePubKey arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = PayeePubKey_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PayeePubKey_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKPayeePubKey orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPayeePubKey ret_var = PayeePubKey_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPayeePubKey o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = PayeePubKey_hash(&o_conv);
return ret_val;
}
LDKPayeePubKey a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKPayeePubKey b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = PayeePubKey_eq(&a_conv, &b_conv);
return ret_val;
}
LDKExpiryTime this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ExpiryTime_free(this_obj_conv);
}
+static inline uint64_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg) {
+ LDKExpiryTime ret_var = ExpiryTime_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ExpiryTime_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKExpiryTime arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ExpiryTime_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_ExpiryTime_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKExpiryTime orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKExpiryTime ret_var = ExpiryTime_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKExpiryTime o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = ExpiryTime_hash(&o_conv);
return ret_val;
}
LDKExpiryTime a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKExpiryTime b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = ExpiryTime_eq(&a_conv, &b_conv);
return ret_val;
}
LDKMinFinalCltvExpiry this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
MinFinalCltvExpiry_free(this_obj_conv);
}
LDKMinFinalCltvExpiry this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = MinFinalCltvExpiry_get_a(&this_ptr_conv);
return ret_val;
}
LDKMinFinalCltvExpiry this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
MinFinalCltvExpiry_set_a(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t MinFinalCltvExpiry_clone_ptr(LDKMinFinalCltvExpiry *NONNULL_PTR arg) {
+ LDKMinFinalCltvExpiry ret_var = MinFinalCltvExpiry_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MinFinalCltvExpiry_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKMinFinalCltvExpiry arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = MinFinalCltvExpiry_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_MinFinalCltvExpiry_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKMinFinalCltvExpiry orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKMinFinalCltvExpiry ret_var = MinFinalCltvExpiry_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKMinFinalCltvExpiry o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = MinFinalCltvExpiry_hash(&o_conv);
return ret_val;
}
LDKMinFinalCltvExpiry a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKMinFinalCltvExpiry b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = MinFinalCltvExpiry_eq(&a_conv, &b_conv);
return ret_val;
}
Fallback_free(this_ptr_conv);
}
+static inline uint64_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg) {
+ LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
+ *ret_copy = Fallback_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Fallback_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKFallback* arg_conv = (LDKFallback*)arg;
+ int64_t ret_val = Fallback_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_Fallback_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKFallback* orig_conv = (LDKFallback*)orig;
LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
LDKInvoiceSignature this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InvoiceSignature_free(this_obj_conv);
}
+static inline uint64_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg) {
+ LDKInvoiceSignature ret_var = InvoiceSignature_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InvoiceSignature_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKInvoiceSignature arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = InvoiceSignature_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_InvoiceSignature_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKInvoiceSignature orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInvoiceSignature ret_var = InvoiceSignature_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvoiceSignature a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKInvoiceSignature b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = InvoiceSignature_eq(&a_conv, &b_conv);
return ret_val;
}
LDKPrivateRoute this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
PrivateRoute_free(this_obj_conv);
}
+static inline uint64_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg) {
+ LDKPrivateRoute ret_var = PrivateRoute_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PrivateRoute_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKPrivateRoute arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = PrivateRoute_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PrivateRoute_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKPrivateRoute orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPrivateRoute ret_var = PrivateRoute_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPrivateRoute o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = PrivateRoute_hash(&o_conv);
return ret_val;
}
LDKPrivateRoute a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKPrivateRoute b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = PrivateRoute_eq(&a_conv, &b_conv);
return ret_val;
}
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
this_arg_conv = SignedRawInvoice_clone(&this_arg_conv);
LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
*ret_conv = SignedRawInvoice_into_parts(this_arg_conv);
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRawInvoice ret_var = SignedRawInvoice_raw_invoice(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *SignedRawInvoice_hash(&this_arg_conv));
return ret_arr;
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInvoiceSignature ret_var = SignedRawInvoice_signature(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
*ret_conv = SignedRawInvoice_recover_payee_pub_key(&this_arg_conv);
return (uint64_t)ret_conv;
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = SignedRawInvoice_check_signature(&this_arg_conv);
return ret_val;
}
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, RawInvoice_hash(&this_arg_conv).data);
return ret_arr;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKSha256 ret_var = RawInvoice_payment_hash(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKDescription ret_var = RawInvoice_description(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPayeePubKey ret_var = RawInvoice_payee_pub_key(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKSha256 ret_var = RawInvoice_description_hash(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKExpiryTime ret_var = RawInvoice_expiry_time(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKMinFinalCltvExpiry ret_var = RawInvoice_min_final_cltv_expiry(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, RawInvoice_payment_secret(&this_arg_conv).data);
return ret_arr;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInvoiceFeatures ret_var = RawInvoice_features(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_PrivateRouteZ ret_var = RawInvoice_private_routes(&this_arg_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_14_ref = 0;
CHECK((((uint64_t)ret_conv_14_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_14_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
ret_conv_14_ref = (uint64_t)ret_conv_14_var.inner;
if (ret_conv_14_var.is_owned) {
ret_conv_14_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = RawInvoice_amount_pico_btc(&this_arg_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jclass ret_conv = LDKCurrency_to_java(env, RawInvoice_currency(&this_arg_conv));
return ret_conv;
}
LDKPositiveTimestamp this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = PositiveTimestamp_as_unix_timestamp(&this_arg_conv);
return ret_val;
}
LDKPositiveTimestamp this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = PositiveTimestamp_as_time(&this_arg_conv);
return ret_val;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
this_arg_conv = Invoice_clone(&this_arg_conv);
LDKSignedRawInvoice ret_var = Invoice_into_signed_raw(this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
*ret_conv = Invoice_check_signature(&this_arg_conv);
return (uint64_t)ret_conv;
LDKSignedRawInvoice signed_invoice_conv;
signed_invoice_conv.inner = (void*)(signed_invoice & (~1));
signed_invoice_conv.is_owned = (signed_invoice & 1) || (signed_invoice == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(signed_invoice_conv);
signed_invoice_conv = SignedRawInvoice_clone(&signed_invoice_conv);
LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
*ret_conv = Invoice_from_signed(signed_invoice_conv);
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = Invoice_timestamp(&this_arg_conv);
return ret_val;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *Invoice_payment_hash(&this_arg_conv));
return ret_arr;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, Invoice_payee_pub_key(&this_arg_conv).compressed_form);
return ret_arr;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 32);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 32, *Invoice_payment_secret(&this_arg_conv));
return ret_arr;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInvoiceFeatures ret_var = Invoice_features(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = (*env)->NewByteArray(env, 33);
(*env)->SetByteArrayRegion(env, ret_arr, 0, 33, Invoice_recover_payee_pub_key(&this_arg_conv).compressed_form);
return ret_arr;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = Invoice_expiry_time(&this_arg_conv);
return ret_val;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = Invoice_is_expired(&this_arg_conv);
return ret_val;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = Invoice_min_final_cltv_expiry(&this_arg_conv);
return ret_val;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_PrivateRouteZ ret_var = Invoice_private_routes(&this_arg_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_14_ref = 0;
CHECK((((uint64_t)ret_conv_14_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_14_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
ret_conv_14_ref = (uint64_t)ret_conv_14_var.inner;
if (ret_conv_14_var.is_owned) {
ret_conv_14_ref |= 1;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_RouteHintZ ret_var = Invoice_route_hints(&this_arg_conv);
int64_tArray ret_arr = NULL;
ret_arr = (*env)->NewLongArray(env, ret_var.datalen);
uint64_t ret_conv_11_ref = 0;
CHECK((((uint64_t)ret_conv_11_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_11_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_11_var);
ret_conv_11_ref = (uint64_t)ret_conv_11_var.inner;
if (ret_conv_11_var.is_owned) {
ret_conv_11_ref |= 1;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jclass ret_conv = LDKCurrency_to_java(env, Invoice_currency(&this_arg_conv));
return ret_conv;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = Invoice_amount_milli_satoshis(&this_arg_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKDescription this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
this_arg_conv = Description_clone(&this_arg_conv);
LDKStr ret_str = Description_into_inner(this_arg_conv);
jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
LDKExpiryTime this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = ExpiryTime_as_seconds(&this_arg_conv);
return ret_val;
}
LDKExpiryTime this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = ExpiryTime_as_duration(&this_arg_conv);
return ret_val;
}
LDKRouteHint hops_conv;
hops_conv.inner = (void*)(hops & (~1));
hops_conv.is_owned = (hops & 1) || (hops == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(hops_conv);
hops_conv = RouteHint_clone(&hops_conv);
LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
*ret_conv = PrivateRoute_new(hops_conv);
LDKPrivateRoute this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
this_arg_conv = PrivateRoute_clone(&this_arg_conv);
LDKRouteHint ret_var = PrivateRoute_into_inner(this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
SignOrCreationError_free(this_ptr_conv);
}
+static inline uint64_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg) {
+ LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
+ *ret_copy = SignOrCreationError_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SignOrCreationError_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKSignOrCreationError* arg_conv = (LDKSignOrCreationError*)arg;
+ int64_t ret_val = SignOrCreationError_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_SignOrCreationError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKSignOrCreationError* orig_conv = (LDKSignOrCreationError*)orig;
LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
LDKInvoicePayer this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InvoicePayer_free(this_obj_conv);
}
LDKRetryAttempts this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RetryAttempts_free(this_obj_conv);
}
LDKRetryAttempts this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = RetryAttempts_get_a(&this_ptr_conv);
return ret_val;
}
LDKRetryAttempts this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RetryAttempts_set_a(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RetryAttempts_clone_ptr(LDKRetryAttempts *NONNULL_PTR arg) {
+ LDKRetryAttempts ret_var = RetryAttempts_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RetryAttempts_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKRetryAttempts arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RetryAttempts_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_RetryAttempts_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKRetryAttempts orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRetryAttempts ret_var = RetryAttempts_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRetryAttempts a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRetryAttempts b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RetryAttempts_eq(&a_conv, &b_conv);
return ret_val;
}
LDKRetryAttempts o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = RetryAttempts_hash(&o_conv);
return ret_val;
}
PaymentError_free(this_ptr_conv);
}
+static inline uint64_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg) {
+ LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
+ *ret_copy = PaymentError_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PaymentError_1clone_1ptr(JNIEnv *env, jclass clz, int64_t arg) {
+ LDKPaymentError* arg_conv = (LDKPaymentError*)arg;
+ int64_t ret_val = PaymentError_clone_ptr(arg_conv);
+ return ret_val;
+}
+
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_PaymentError_1clone(JNIEnv *env, jclass clz, int64_t orig) {
LDKPaymentError* orig_conv = (LDKPaymentError*)orig;
LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
LDKLightningError a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = LightningError_clone(&a_conv);
LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
*ret_copy = PaymentError_routing(a_conv);
LDKLockableScore scorer_conv;
scorer_conv.inner = (void*)(scorer & (~1));
scorer_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(scorer_conv);
void* logger_ptr = (void*)(((uint64_t)logger) & ~1);
CHECK_ACCESS(logger_ptr);
LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
LDKRetryAttempts retry_attempts_conv;
retry_attempts_conv.inner = (void*)(retry_attempts & (~1));
retry_attempts_conv.is_owned = (retry_attempts & 1) || (retry_attempts == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(retry_attempts_conv);
retry_attempts_conv = RetryAttempts_clone(&retry_attempts_conv);
LDKInvoicePayer ret_var = InvoicePayer_new(payer_conv, router_conv, &scorer_conv, logger_conv, event_handler_conv, retry_attempts_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvoicePayer this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInvoice invoice_conv;
invoice_conv.inner = (void*)(invoice & (~1));
invoice_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
*ret_conv = InvoicePayer_pay_invoice(&this_arg_conv, &invoice_conv);
return (uint64_t)ret_conv;
LDKInvoicePayer this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInvoice invoice_conv;
invoice_conv.inner = (void*)(invoice & (~1));
invoice_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
*ret_conv = InvoicePayer_pay_zero_value_invoice(&this_arg_conv, &invoice_conv, amount_msats);
return (uint64_t)ret_conv;
LDKInvoicePayer this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char payment_hash_arr[32];
CHECK((*env)->GetArrayLength(env, payment_hash) == 32);
(*env)->GetByteArrayRegion(env, payment_hash, 0, 32, payment_hash_arr);
LDKInvoicePayer this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKEventHandler* ret_ret = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
*ret_ret = InvoicePayer_as_EventHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager channelmanager_conv;
channelmanager_conv.inner = (void*)(channelmanager & (~1));
channelmanager_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
void* keys_manager_ptr = (void*)(((uint64_t)keys_manager) & ~1);
CHECK_ACCESS(keys_manager_ptr);
LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(keys_manager_ptr);
LDKDefaultRouter this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DefaultRouter_free(this_obj_conv);
}
LDKNetworkGraph network_graph_conv;
network_graph_conv.inner = (void*)(network_graph & (~1));
network_graph_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
void* logger_ptr = (void*)(((uint64_t)logger) & ~1);
CHECK_ACCESS(logger_ptr);
LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDefaultRouter this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRouter* ret_ret = MALLOC(sizeof(LDKRouter), "LDKRouter");
*ret_ret = DefaultRouter_as_Router(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPayer* ret_ret = MALLOC(sizeof(LDKPayer), "LDKPayer");
*ret_ret = ChannelManager_as_Payer(&this_arg_conv);
return (uint64_t)ret_ret;
LDKInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
LDKStr ret_str = Invoice_to_str(&o_conv);
jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
Str_free(ret_str);
LDKSignedRawInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
LDKStr ret_str = SignedRawInvoice_to_str(&o_conv);
jstring ret_conv = str_ref_to_java(env, ret_str.chars, ret_str.len);
Str_free(ret_str);
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_new_1empty_1slice_1vec
(JNIEnv *, jclass);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_u8Z_new
- * Signature: ([B)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1u8Z_1new
- (JNIEnv *, jclass, jbyteArray);
-
/*
* Class: org_ldk_impl_bindings
* Method: TxOut_get_script_pubkey
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_TxOut_1get_1value
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_SecretKeyErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SecretKeyErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_SecretKeyErrorZ_get_ok
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SecretKeyErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_PublicKeyErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PublicKeyErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_PublicKeyErrorZ_get_ok
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PublicKeyErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_TxCreationKeysDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_TxCreationKeysDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_ChannelPublicKeysDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelPublicKeysDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_ChannelPublicKeysDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelPublicKeysDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_TxCreationKeysErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxCreationKeysErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_TxCreationKeysErrorZ_get_ok
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1u32Z_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCOutputInCommitmentDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCOutputInCommitmentDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_ChannelTransactionParametersDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelTransactionParametersDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_ChannelTransactionParametersDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelTransactionParametersDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_HolderCommitmentTransactionDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HolderCommitmentTransactionDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_HolderCommitmentTransactionDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HolderCommitmentTransactionDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_BuiltCommitmentTransactionDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1BuiltCommitmentTransactionDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1BuiltCommitmentTransactionDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_TrustedClosingTransactionNoneZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TrustedClosingTransactionNoneZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_TrustedClosingTransactionNoneZ_get_ok
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TrustedClosingTransactionNoneZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_CommitmentTransactionDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentTransactionDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_CommitmentTransactionDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentTransactionDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_TrustedCommitmentTransactionNoneZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TrustedCommitmentTransactionNoneZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_TrustedCommitmentTransactionNoneZ_get_ok
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TrustedCommitmentTransactionNoneZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_CVec_SignatureZNoneZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1SignatureZNoneZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_CVec_SignatureZNoneZ_get_ok
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1SignatureZNoneZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_ShutdownScriptDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownScriptDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_ShutdownScriptDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownScriptDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_ShutdownScriptInvalidShutdownScriptZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownScriptInvalidShutdownScriptZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_ShutdownScriptInvalidShutdownScriptZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownScriptInvalidShutdownScriptZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_NoneErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_NoneErrorZ_get_ok
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_RouteHopDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteHopDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_RouteHopDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteHopDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_RouteHopZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1RouteHopZ_1new
- (JNIEnv *, jclass, jlongArray);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_RouteDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_RouteDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_RouteParametersDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteParametersDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_RouteParametersDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteParametersDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_RouteHintZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1RouteHintZ_1new
- (JNIEnv *, jclass, jlongArray);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCOption_u64Z_ref_from_ptr
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1u64Z_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_PayeeDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PayeeDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_PayeeDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PayeeDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_RouteHintHopZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1RouteHintHopZ_1new
- (JNIEnv *, jclass, jlongArray);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_RouteHintDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteHintDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_RouteHintDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteHintDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_RouteHintHopDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteHintHopDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_RouteHintHopDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteHintHopDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_ChannelDetailsZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1ChannelDetailsZ_1new
- (JNIEnv *, jclass, jlongArray);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_RouteLightningErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteLightningErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_RouteLightningErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RouteLightningErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_TxOutAccessErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TxOutAccessErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_TxOutAccessErrorZ_get_ok
JNIEXPORT jbyteArray JNICALL Java_org_ldk_impl_bindings_C2Tuple_1usizeTransactionZ_1get_1b
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_C2Tuple_usizeTransactionZZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1usizeTransactionZZ_1new
- (JNIEnv *, jclass, jlongArray);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_NoneChannelMonitorUpdateErrZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneChannelMonitorUpdateErrZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_NoneChannelMonitorUpdateErrZ_get_ok
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKMonitorEvent_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_MonitorEventZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1MonitorEventZ_1new
- (JNIEnv *, jclass, jlongArray);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCOption_C2Tuple_usizeTransactionZZ_ref_from_ptr
/*
* Class: org_ldk_impl_bindings
- * Method: LDKNetworkUpdate_ref_from_ptr
- * Signature: (J)Lorg/ldk/impl/bindings/LDKNetworkUpdate;
+ * Method: LDKClosureReason_ref_from_ptr
+ * Signature: (J)Lorg/ldk/impl/bindings/LDKClosureReason;
*/
-JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKNetworkUpdate_1ref_1from_1ptr
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKClosureReason_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCOption_NetworkUpdateZ_ref_from_ptr
- * Signature: (J)Lorg/ldk/impl/bindings/LDKCOption_NetworkUpdateZ;
+ * Method: LDKCOption_ClosureReasonZ_ref_from_ptr
+ * Signature: (J)Lorg/ldk/impl/bindings/LDKCOption_ClosureReasonZ;
*/
-JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1NetworkUpdateZ_1ref_1from_1ptr
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1ClosureReasonZ_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKSpendableOutputDescriptor_ref_from_ptr
- * Signature: (J)Lorg/ldk/impl/bindings/LDKSpendableOutputDescriptor;
+ * Method: LDKCResult_COption_ClosureReasonZDecodeErrorZ_get_ok
+ * Signature: (J)J
*/
-JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKSpendableOutputDescriptor_1ref_1from_1ptr
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1ClosureReasonZDecodeErrorZ_1get_1ok
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCVec_SpendableOutputDescriptorZ_new
- * Signature: ([J)J
+ * Method: LDKCResult_COption_ClosureReasonZDecodeErrorZ_get_err
+ * Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1SpendableOutputDescriptorZ_1new
- (JNIEnv *, jclass, jlongArray);
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1ClosureReasonZDecodeErrorZ_1get_1err
+ (JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKErrorAction_ref_from_ptr
- * Signature: (J)Lorg/ldk/impl/bindings/LDKErrorAction;
+ * Method: LDKNetworkUpdate_ref_from_ptr
+ * Signature: (J)Lorg/ldk/impl/bindings/LDKNetworkUpdate;
*/
-JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKErrorAction_1ref_1from_1ptr
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKNetworkUpdate_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKMessageSendEvent_ref_from_ptr
- * Signature: (J)Lorg/ldk/impl/bindings/LDKMessageSendEvent;
+ * Method: LDKCOption_NetworkUpdateZ_ref_from_ptr
+ * Signature: (J)Lorg/ldk/impl/bindings/LDKCOption_NetworkUpdateZ;
*/
-JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKMessageSendEvent_1ref_1from_1ptr
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1NetworkUpdateZ_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCVec_MessageSendEventZ_new
- * Signature: ([J)J
+ * Method: LDKSpendableOutputDescriptor_ref_from_ptr
+ * Signature: (J)Lorg/ldk/impl/bindings/LDKSpendableOutputDescriptor;
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1MessageSendEventZ_1new
- (JNIEnv *, jclass, jlongArray);
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKSpendableOutputDescriptor_1ref_1from_1ptr
+ (JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_InitFeaturesDecodeErrorZ_result_ok
- * Signature: (J)Z
+ * Method: LDKPaymentPurpose_ref_from_ptr
+ * Signature: (J)Lorg/ldk/impl/bindings/LDKPaymentPurpose;
*/
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1result_1ok
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKPaymentPurpose_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_InitFeaturesDecodeErrorZ_get_ok
- * Signature: (J)J
+ * Method: LDKEvent_ref_from_ptr
+ * Signature: (J)Lorg/ldk/impl/bindings/LDKEvent;
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1get_1ok
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKEvent_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_InitFeaturesDecodeErrorZ_get_err
- * Signature: (J)J
+ * Method: LDKCOption_EventZ_ref_from_ptr
+ * Signature: (J)Lorg/ldk/impl/bindings/LDKCOption_EventZ;
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1get_1err
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1EventZ_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_NodeFeaturesDecodeErrorZ_result_ok
- * Signature: (J)Z
+ * Method: LDKCResult_COption_EventZDecodeErrorZ_get_ok
+ * Signature: (J)J
*/
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1result_1ok
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1EventZDecodeErrorZ_1get_1ok
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_NodeFeaturesDecodeErrorZ_get_ok
+ * Method: LDKCResult_COption_EventZDecodeErrorZ_get_err
* Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1get_1ok
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1EventZDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_NodeFeaturesDecodeErrorZ_get_err
- * Signature: (J)J
+ * Method: LDKErrorAction_ref_from_ptr
+ * Signature: (J)Lorg/ldk/impl/bindings/LDKErrorAction;
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1get_1err
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKErrorAction_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_ChannelFeaturesDecodeErrorZ_result_ok
- * Signature: (J)Z
+ * Method: LDKMessageSendEvent_ref_from_ptr
+ * Signature: (J)Lorg/ldk/impl/bindings/LDKMessageSendEvent;
*/
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1result_1ok
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKMessageSendEvent_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_ChannelFeaturesDecodeErrorZ_get_ok
+ * Method: LDKCResult_InitFeaturesDecodeErrorZ_get_ok
* Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1get_1ok
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1get_1ok
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_ChannelFeaturesDecodeErrorZ_get_err
+ * Method: LDKCResult_InitFeaturesDecodeErrorZ_get_err
* Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1get_1err
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitFeaturesDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_InvoiceFeaturesDecodeErrorZ_result_ok
- * Signature: (J)Z
+ * Method: LDKCResult_NodeFeaturesDecodeErrorZ_get_ok
+ * Signature: (J)J
*/
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceFeaturesDecodeErrorZ_1result_1ok
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1get_1ok
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_InvoiceFeaturesDecodeErrorZ_get_ok
+ * Method: LDKCResult_NodeFeaturesDecodeErrorZ_get_err
* Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceFeaturesDecodeErrorZ_1get_1ok
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeFeaturesDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_InvoiceFeaturesDecodeErrorZ_get_err
+ * Method: LDKCResult_ChannelFeaturesDecodeErrorZ_get_ok
* Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceFeaturesDecodeErrorZ_1get_1err
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1get_1ok
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_ScoringParametersDecodeErrorZ_result_ok
- * Signature: (J)Z
+ * Method: LDKCResult_ChannelFeaturesDecodeErrorZ_get_err
+ * Signature: (J)J
*/
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ScoringParametersDecodeErrorZ_1result_1ok
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelFeaturesDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_ScoringParametersDecodeErrorZ_get_ok
+ * Method: LDKCResult_InvoiceFeaturesDecodeErrorZ_get_ok
* Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ScoringParametersDecodeErrorZ_1get_1ok
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceFeaturesDecodeErrorZ_1get_1ok
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_ScoringParametersDecodeErrorZ_get_err
+ * Method: LDKCResult_InvoiceFeaturesDecodeErrorZ_get_err
* Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ScoringParametersDecodeErrorZ_1get_1err
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceFeaturesDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_ScorerDecodeErrorZ_result_ok
- * Signature: (J)Z
+ * Method: LDKCResult_ScoringParametersDecodeErrorZ_get_ok
+ * Signature: (J)J
*/
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ScorerDecodeErrorZ_1result_1ok
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ScoringParametersDecodeErrorZ_1get_1ok
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_ScorerDecodeErrorZ_get_ok
+ * Method: LDKCResult_ScoringParametersDecodeErrorZ_get_err
* Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ScorerDecodeErrorZ_1get_1ok
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ScoringParametersDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_ScorerDecodeErrorZ_get_err
+ * Method: LDKCResult_ScorerDecodeErrorZ_get_ok
* Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ScorerDecodeErrorZ_1get_1err
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ScorerDecodeErrorZ_1get_1ok
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ_result_ok
- * Signature: (J)Z
+ * Method: LDKCResult_ScorerDecodeErrorZ_get_err
+ * Signature: (J)J
*/
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1result_1ok
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ScorerDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
/*
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_SpendableOutputDescriptorDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SpendableOutputDescriptorDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_SpendableOutputDescriptorDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SpendableOutputDescriptorDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_NoneNoneZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneNoneZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_NoneNoneZ_get_ok
JNIEXPORT jobjectArray JNICALL Java_org_ldk_impl_bindings_C2Tuple_1SignatureCVec_1SignatureZZ_1get_1b
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_SignatureNoneZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignatureNoneZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_SignatureNoneZ_get_ok
JNIEXPORT jbyteArray JNICALL Java_org_ldk_impl_bindings_Sign_1write
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_SignDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_SignDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_RecoverableSignatureNoneZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RecoverableSignatureNoneZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_RecoverableSignatureNoneZ_get_ok
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RecoverableSignatureNoneZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_CVec_CVec_u8ZZNoneZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1CVec_1u8ZZNoneZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_CVec_CVec_u8ZZNoneZ_get_ok
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1CVec_1u8ZZNoneZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_InMemorySignerDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InMemorySignerDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_InMemorySignerDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InMemorySignerDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_TxOutZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1TxOutZ_1new
- (JNIEnv *, jclass, jlongArray);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_TransactionNoneZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1TransactionNoneZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_TransactionNoneZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C2Tuple_1BlockHashChannelMonitorZ_1get_1b
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_C2Tuple_BlockHashChannelMonitorZZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1BlockHashChannelMonitorZZ_1new
- (JNIEnv *, jclass, jlongArray);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_get_ok
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKAPIError_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_NoneAPIErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneAPIErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_NoneAPIErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneAPIErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_CResult_NoneAPIErrorZZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1CResult_1NoneAPIErrorZZ_1new
- (JNIEnv *, jclass, jlongArray);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_APIErrorZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1APIErrorZ_1new
- (JNIEnv *, jclass, jlongArray);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult__u832APIErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1_1u832APIErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult__u832APIErrorZ_get_ok
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKPaymentSendFailure_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_PaymentIdPaymentSendFailureZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PaymentIdPaymentSendFailureZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_PaymentIdPaymentSendFailureZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PaymentIdPaymentSendFailureZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_NonePaymentSendFailureZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePaymentSendFailureZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_NonePaymentSendFailureZ_get_ok
JNIEXPORT jbyteArray JNICALL Java_org_ldk_impl_bindings_C2Tuple_1PaymentHashPaymentIdZ_1get_1b
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1PaymentHashPaymentIdZPaymentSendFailureZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKNetAddress_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_NetAddressZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1NetAddressZ_1new
- (JNIEnv *, jclass, jlongArray);
-
/*
* Class: org_ldk_impl_bindings
* Method: C2Tuple_PaymentHashPaymentSecretZ_get_a
JNIEXPORT jbyteArray JNICALL Java_org_ldk_impl_bindings_C2Tuple_1PaymentHashPaymentSecretZ_1get_1b
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_PaymentSecretAPIErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PaymentSecretAPIErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_PaymentSecretAPIErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PaymentSecretAPIErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_ChannelMonitorZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1ChannelMonitorZ_1new
- (JNIEnv *, jclass, jlongArray);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKWatch_new
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C2Tuple_1BlockHashChannelManagerZ_1get_1b
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_ChannelConfigDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_ChannelConfigDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelConfigDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_OutPointDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OutPointDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_OutPointDecodeErrorZ_get_ok
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1TypeZ_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_COption_TypeZDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1TypeZDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_COption_TypeZDecodeErrorZ_get_ok
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKPaymentError_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_PaymentIdPaymentErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PaymentIdPaymentErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_PaymentIdPaymentErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PaymentIdPaymentErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_SiPrefixNoneZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SiPrefixNoneZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_SiPrefixNoneZ_get_ok
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SiPrefixNoneZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_InvoiceNoneZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceNoneZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_InvoiceNoneZ_get_ok
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceNoneZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_SignedRawInvoiceNoneZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1SignedRawInvoiceNoneZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_SignedRawInvoiceNoneZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C3Tuple_1RawInvoice_1u832InvoiceSignatureZ_1get_1c
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_PayeePubKeyErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PayeePubKeyErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_PayeePubKeyErrorZ_get_ok
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PayeePubKeyErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_PrivateRouteZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1PrivateRouteZ_1new
- (JNIEnv *, jclass, jlongArray);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_PositiveTimestampCreationErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PositiveTimestampCreationErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_PositiveTimestampCreationErrorZ_get_ok
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PositiveTimestampCreationErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_NoneSemanticErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneSemanticErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_NoneSemanticErrorZ_get_ok
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneSemanticErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_InvoiceSemanticErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceSemanticErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_InvoiceSemanticErrorZ_get_ok
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceSemanticErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_DescriptionCreationErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DescriptionCreationErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_DescriptionCreationErrorZ_get_ok
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DescriptionCreationErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_ExpiryTimeCreationErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ExpiryTimeCreationErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_ExpiryTimeCreationErrorZ_get_ok
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ExpiryTimeCreationErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_PrivateRouteCreationErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PrivateRouteCreationErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_PrivateRouteCreationErrorZ_get_ok
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PrivateRouteCreationErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_StringErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1StringErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_StringErrorZ_get_ok
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCResult_1StringErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_ChannelMonitorUpdateDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelMonitorUpdateDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_ChannelMonitorUpdateDecodeErrorZ_get_ok
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_HTLCUpdateDecodeErrorZ_result_ok
- * Signature: (J)Z
+ * Method: LDKCOption_MonitorEventZ_ref_from_ptr
+ * Signature: (J)Lorg/ldk/impl/bindings/LDKCOption_MonitorEventZ;
*/
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCUpdateDecodeErrorZ_1result_1ok
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1MonitorEventZ_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_HTLCUpdateDecodeErrorZ_get_ok
+ * Method: LDKCResult_COption_MonitorEventZDecodeErrorZ_get_ok
* Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCUpdateDecodeErrorZ_1get_1ok
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1MonitorEventZDecodeErrorZ_1get_1ok
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_HTLCUpdateDecodeErrorZ_get_err
+ * Method: LDKCResult_COption_MonitorEventZDecodeErrorZ_get_err
* Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCUpdateDecodeErrorZ_1get_1err
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1MonitorEventZDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_NoneMonitorUpdateErrorZ_result_ok
- * Signature: (J)Z
+ * Method: LDKCResult_HTLCUpdateDecodeErrorZ_get_ok
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCUpdateDecodeErrorZ_1get_1ok
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: LDKCResult_HTLCUpdateDecodeErrorZ_get_err
+ * Signature: (J)J
*/
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneMonitorUpdateErrorZ_1result_1ok
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1HTLCUpdateDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
/*
JNIEXPORT jbyteArray JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32ScriptZ_1get_1b
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_C2Tuple_u32ScriptZZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1u32ScriptZZ_1new
- (JNIEnv *, jclass, jlongArray);
-
/*
* Class: org_ldk_impl_bindings
* Method: C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a
JNIEXPORT jlongArray JNICALL Java_org_ldk_impl_bindings_C2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZ_1get_1b
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZZ_1new
- (JNIEnv *, jclass, jlongArray);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKPaymentPurpose_ref_from_ptr
- * Signature: (J)Lorg/ldk/impl/bindings/LDKPaymentPurpose;
- */
-JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKPaymentPurpose_1ref_1from_1ptr
- (JNIEnv *, jclass, jlong);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKClosureReason_ref_from_ptr
- * Signature: (J)Lorg/ldk/impl/bindings/LDKClosureReason;
- */
-JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKClosureReason_1ref_1from_1ptr
- (JNIEnv *, jclass, jlong);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKEvent_ref_from_ptr
- * Signature: (J)Lorg/ldk/impl/bindings/LDKEvent;
- */
-JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKEvent_1ref_1from_1ptr
- (JNIEnv *, jclass, jlong);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_EventZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1EventZ_1new
- (JNIEnv *, jclass, jlongArray);
-
/*
* Class: org_ldk_impl_bindings
* Method: C2Tuple_u32TxOutZ_get_a
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32TxOutZ_1get_1b
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_C2Tuple_u32TxOutZZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1u32TxOutZZ_1new
- (JNIEnv *, jclass, jlongArray);
-
/*
* Class: org_ldk_impl_bindings
* Method: C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a
JNIEXPORT jlongArray JNICALL Java_org_ldk_impl_bindings_C2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZ_1get_1b
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZZ_1new
- (JNIEnv *, jclass, jlongArray);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKBalance_ref_from_ptr
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKBalance_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_BalanceZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1BalanceZ_1new
- (JNIEnv *, jclass, jlongArray);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_NoneLightningErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NoneLightningErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_NoneLightningErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C2Tuple_1PublicKeyTypeZ_1get_1b
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_C2Tuple_PublicKeyTypeZZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C2Tuple_1PublicKeyTypeZZ_1new
- (JNIEnv *, jclass, jlongArray);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_boolLightningErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolLightningErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_boolLightningErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1get_1c
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZZ_1new
- (JNIEnv *, jclass, jlongArray);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_NodeAnnouncementZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1NodeAnnouncementZ_1new
- (JNIEnv *, jclass, jlongArray);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_CVec_u8ZPeerHandleErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_CVec_u8ZPeerHandleErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CVec_1u8ZPeerHandleErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_NonePeerHandleErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NonePeerHandleErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_NonePeerHandleErrorZ_get_ok
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_boolPeerHandleErrorZ_result_ok
+ * Method: LDKCResult_boolPeerHandleErrorZ_get_ok
* Signature: (J)Z
*/
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1result_1ok
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1get_1ok
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_boolPeerHandleErrorZ_get_ok
- * Signature: (J)Z
+ * Method: LDKCResult_boolPeerHandleErrorZ_get_err
+ * Signature: (J)J
*/
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1get_1ok
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_boolPeerHandleErrorZ_get_err
+ * Method: LDKCResult_NodeIdDecodeErrorZ_get_ok
* Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1boolPeerHandleErrorZ_1get_1err
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeIdDecodeErrorZ_1get_1ok
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_NodeIdDecodeErrorZ_result_ok
- * Signature: (J)Z
+ * Method: LDKCResult_NodeIdDecodeErrorZ_get_err
+ * Signature: (J)J
*/
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeIdDecodeErrorZ_1result_1ok
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeIdDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_NodeIdDecodeErrorZ_get_ok
+ * Method: LDKCResult_COption_NetworkUpdateZDecodeErrorZ_get_ok
* Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeIdDecodeErrorZ_1get_1ok
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1NetworkUpdateZDecodeErrorZ_1get_1ok
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCResult_NodeIdDecodeErrorZ_get_err
+ * Method: LDKCResult_COption_NetworkUpdateZDecodeErrorZ_get_err
* Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeIdDecodeErrorZ_1get_1err
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1COption_1NetworkUpdateZDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
/*
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1AccessZ_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_DirectionalChannelInfoDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DirectionalChannelInfoDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1DirectionalChannelInfoDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_ChannelInfoDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelInfoDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_ChannelInfoDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelInfoDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_RoutingFeesDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RoutingFeesDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_RoutingFeesDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RoutingFeesDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_NodeAnnouncementInfoDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementInfoDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_NodeAnnouncementInfoDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementInfoDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_u64Z_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1u64Z_1new
- (JNIEnv *, jclass, jlongArray);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_NodeInfoDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeInfoDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_NodeInfoDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeInfoDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_NetworkGraphDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetworkGraphDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_NetworkGraphDecodeErrorZ_get_ok
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1CVec_1NetAddressZZ_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_NetAddressDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NetAddressDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_NetAddressDecodeErrorZ_get_ok
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCVec_UpdateAddHTLCZ_new
- * Signature: ([J)J
+ * Method: LDKCResult_AcceptChannelDecodeErrorZ_get_ok
+ * Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1UpdateAddHTLCZ_1new
- (JNIEnv *, jclass, jlongArray);
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AcceptChannelDecodeErrorZ_1get_1ok
+ (JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCVec_UpdateFulfillHTLCZ_new
- * Signature: ([J)J
+ * Method: LDKCResult_AcceptChannelDecodeErrorZ_get_err
+ * Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1UpdateFulfillHTLCZ_1new
- (JNIEnv *, jclass, jlongArray);
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AcceptChannelDecodeErrorZ_1get_1err
+ (JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCVec_UpdateFailHTLCZ_new
- * Signature: ([J)J
+ * Method: LDKCResult_AnnouncementSignaturesDecodeErrorZ_get_ok
+ * Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1UpdateFailHTLCZ_1new
- (JNIEnv *, jclass, jlongArray);
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AnnouncementSignaturesDecodeErrorZ_1get_1ok
+ (JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: LDKCVec_UpdateFailMalformedHTLCZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1UpdateFailMalformedHTLCZ_1new
- (JNIEnv *, jclass, jlongArray);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_AcceptChannelDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AcceptChannelDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_AcceptChannelDecodeErrorZ_get_ok
- * Signature: (J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AcceptChannelDecodeErrorZ_1get_1ok
- (JNIEnv *, jclass, jlong);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_AcceptChannelDecodeErrorZ_get_err
- * Signature: (J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AcceptChannelDecodeErrorZ_1get_1err
- (JNIEnv *, jclass, jlong);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_AnnouncementSignaturesDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AnnouncementSignaturesDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_AnnouncementSignaturesDecodeErrorZ_get_ok
- * Signature: (J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AnnouncementSignaturesDecodeErrorZ_1get_1ok
- (JNIEnv *, jclass, jlong);
-
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_AnnouncementSignaturesDecodeErrorZ_get_err
- * Signature: (J)J
+ * Method: LDKCResult_AnnouncementSignaturesDecodeErrorZ_get_err
+ * Signature: (J)J
*/
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1AnnouncementSignaturesDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_ChannelReestablishDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelReestablishDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_ChannelReestablishDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelReestablishDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_ClosingSignedDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ClosingSignedDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_ClosingSignedDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ClosingSignedDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_ClosingSignedFeeRangeDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ClosingSignedFeeRangeDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ClosingSignedFeeRangeDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_CommitmentSignedDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentSignedDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_CommitmentSignedDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1CommitmentSignedDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_FundingCreatedDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingCreatedDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_FundingCreatedDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingCreatedDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_FundingSignedDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingSignedDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_FundingSignedDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingSignedDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_FundingLockedDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingLockedDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_FundingLockedDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1FundingLockedDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_InitDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_InitDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InitDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_OpenChannelDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OpenChannelDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_OpenChannelDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1OpenChannelDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_RevokeAndACKDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RevokeAndACKDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_RevokeAndACKDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1RevokeAndACKDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_ShutdownDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_ShutdownDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ShutdownDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_UpdateFailHTLCDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailHTLCDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_UpdateFailHTLCDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailHTLCDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailMalformedHTLCDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFailMalformedHTLCDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_UpdateFeeDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFeeDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_UpdateFeeDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFeeDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_UpdateFulfillHTLCDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFulfillHTLCDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_UpdateFulfillHTLCDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateFulfillHTLCDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_UpdateAddHTLCDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateAddHTLCDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_UpdateAddHTLCDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UpdateAddHTLCDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_PingDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PingDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_PingDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PingDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_PongDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PongDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_PongDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1PongDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelAnnouncementDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelAnnouncementDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_ChannelAnnouncementDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelAnnouncementDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_ChannelAnnouncementDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelAnnouncementDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_UnsignedChannelUpdateDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelUpdateDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_UnsignedChannelUpdateDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedChannelUpdateDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_ChannelUpdateDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelUpdateDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_ChannelUpdateDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ChannelUpdateDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_ErrorMessageDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ErrorMessageDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_ErrorMessageDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ErrorMessageDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedNodeAnnouncementDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1UnsignedNodeAnnouncementDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_NodeAnnouncementDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_NodeAnnouncementDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1NodeAnnouncementDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_QueryShortChannelIdsDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryShortChannelIdsDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_QueryShortChannelIdsDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryShortChannelIdsDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyShortChannelIdsEndDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyShortChannelIdsEndDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_QueryChannelRangeDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryChannelRangeDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_QueryChannelRangeDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1QueryChannelRangeDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_ReplyChannelRangeDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyChannelRangeDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_ReplyChannelRangeDecodeErrorZ_get_ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCResult_1ReplyChannelRangeDecodeErrorZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_GossipTimestampFilterDecodeErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1GossipTimestampFilterDecodeErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_GossipTimestampFilterDecodeErrorZ_get_ok
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKSignOrCreationError_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_InvoiceSignOrCreationErrorZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1InvoiceSignOrCreationErrorZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_InvoiceSignOrCreationErrorZ_get_ok
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_LDKCOption_1FilterZ_1ref_1from_1ptr
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCResult_LockedChannelMonitorNoneZ_result_ok
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_LDKCResult_1LockedChannelMonitorNoneZ_1result_1ok
- (JNIEnv *, jclass, jlong);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKCResult_LockedChannelMonitorNoneZ_get_ok
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_LDKCResult_1LockedChannelMonitorNoneZ_1get_1err
(JNIEnv *, jclass, jlong);
-/*
- * Class: org_ldk_impl_bindings
- * Method: LDKCVec_OutPointZ_new
- * Signature: ([J)J
- */
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LDKCVec_1OutPointZ_1new
- (JNIEnv *, jclass, jlongArray);
-
/*
* Class: org_ldk_impl_bindings
* Method: LDKMessageSendEventsProvider_new
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_TxOut_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: TxOut_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_TxOut_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: TxOut_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1SecretKeyErrorZ_1err
(JNIEnv *, jclass, jobject);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_SecretKeyErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1SecretKeyErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_SecretKeyErrorZ_free
/*
* Class: org_ldk_impl_bindings
- * Method: CResult_PublicKeyErrorZ_free
- * Signature: (J)V
+ * Method: CResult_PublicKeyErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PublicKeyErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PublicKeyErrorZ_free
+ * Signature: (J)V
*/
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PublicKeyErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PublicKeyErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PublicKeyErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_PublicKeyErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_TxCreationKeysDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_TxCreationKeysDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_TxCreationKeysDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_TxCreationKeysDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelPublicKeysDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ChannelPublicKeysDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelPublicKeysDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ChannelPublicKeysDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelPublicKeysDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelPublicKeysDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ChannelPublicKeysDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysErrorZ_1err
(JNIEnv *, jclass, jobject);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_TxCreationKeysErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_TxCreationKeysErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_TxCreationKeysErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1TxCreationKeysErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_TxCreationKeysErrorZ_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1u32Z_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: COption_u32Z_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_COption_1u32Z_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: COption_u32Z_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCOutputInCommitmentDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCOutputInCommitmentDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_HTLCOutputInCommitmentDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCOutputInCommitmentDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCOutputInCommitmentDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_HTLCOutputInCommitmentDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1CounterpartyChannelTransactionParametersDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelTransactionParametersDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ChannelTransactionParametersDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelTransactionParametersDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ChannelTransactionParametersDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelTransactionParametersDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelTransactionParametersDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ChannelTransactionParametersDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1HolderCommitmentTransactionDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1HolderCommitmentTransactionDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_HolderCommitmentTransactionDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1HolderCommitmentTransactionDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1HolderCommitmentTransactionDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_HolderCommitmentTransactionDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1BuiltCommitmentTransactionDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1BuiltCommitmentTransactionDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_BuiltCommitmentTransactionDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1BuiltCommitmentTransactionDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1BuiltCommitmentTransactionDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_BuiltCommitmentTransactionDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedClosingTransactionNoneZ_1err
(JNIEnv *, jclass);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_TrustedClosingTransactionNoneZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedClosingTransactionNoneZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_TrustedClosingTransactionNoneZ_free
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentTransactionDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_CommitmentTransactionDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentTransactionDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_CommitmentTransactionDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentTransactionDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_CommitmentTransactionDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentTransactionDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_CommitmentTransactionDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedCommitmentTransactionNoneZ_1err
(JNIEnv *, jclass);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_TrustedCommitmentTransactionNoneZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1TrustedCommitmentTransactionNoneZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_TrustedCommitmentTransactionNoneZ_free
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1err
(JNIEnv *, jclass);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_CVec_SignatureZNoneZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_CVec_SignatureZNoneZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_CVec_SignatureZNoneZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1SignatureZNoneZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_CVec_SignatureZNoneZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ShutdownScriptDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ShutdownScriptDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ShutdownScriptDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ShutdownScriptDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptInvalidShutdownScriptZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptInvalidShutdownScriptZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ShutdownScriptInvalidShutdownScriptZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptInvalidShutdownScriptZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownScriptInvalidShutdownScriptZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ShutdownScriptInvalidShutdownScriptZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneErrorZ_1err
(JNIEnv *, jclass, jobject);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NoneErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NoneErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NoneErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NoneErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NoneErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHopDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_RouteHopDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHopDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_RouteHopDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHopDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_RouteHopDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHopDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_RouteHopDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1RouteDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_RouteDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RouteDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_RouteDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_RouteDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1RouteDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_RouteDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1RouteParametersDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_RouteParametersDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RouteParametersDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_RouteParametersDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteParametersDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_RouteParametersDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1RouteParametersDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_RouteParametersDecodeErrorZ_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1u64Z_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: COption_u64Z_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_COption_1u64Z_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: COption_u64Z_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PayeeDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PayeeDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PayeeDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_PayeeDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PayeeDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PayeeDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PayeeDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_PayeeDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_RouteHintDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_RouteHintDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_RouteHintDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_RouteHintDecodeErrorZ_clone
/*
* Class: org_ldk_impl_bindings
- * Method: CResult_RouteHintHopDecodeErrorZ_free
- * Signature: (J)V
+ * Method: CResult_RouteHintHopDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintHopDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_RouteHintHopDecodeErrorZ_free
+ * Signature: (J)V
*/
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintHopDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_RouteHintHopDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1RouteHintHopDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_RouteHintHopDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1RouteLightningErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_RouteLightningErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RouteLightningErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_RouteLightningErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RouteLightningErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_RouteLightningErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1RouteLightningErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_RouteLightningErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1TxOutAccessErrorZ_1err
(JNIEnv *, jclass, jobject);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_TxOutAccessErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1TxOutAccessErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_TxOutAccessErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TxOutAccessErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_TxOutAccessErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1TxOutAccessErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_TxOutAccessErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1TxOutAccessErrorZ_1clone
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: C2Tuple_usizeTransactionZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C2Tuple_1usizeTransactionZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: C2Tuple_usizeTransactionZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneChannelMonitorUpdateErrZ_1err
(JNIEnv *, jclass, jobject);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NoneChannelMonitorUpdateErrZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NoneChannelMonitorUpdateErrZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NoneChannelMonitorUpdateErrZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneChannelMonitorUpdateErrZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NoneChannelMonitorUpdateErrZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneChannelMonitorUpdateErrZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NoneChannelMonitorUpdateErrZ_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1C2Tuple_1usizeTransactionZZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: COption_C2Tuple_usizeTransactionZZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_COption_1C2Tuple_1usizeTransactionZZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: COption_C2Tuple_usizeTransactionZZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_COption_1C2Tuple_1usizeTransactionZZ_1clone
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: COption_ClosureReasonZ_some
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_COption_1ClosureReasonZ_1some
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: COption_ClosureReasonZ_none
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_COption_1ClosureReasonZ_1none
+ (JNIEnv *, jclass);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: COption_ClosureReasonZ_free
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1ClosureReasonZ_1free
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: COption_ClosureReasonZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_COption_1ClosureReasonZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: COption_ClosureReasonZ_clone
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_COption_1ClosureReasonZ_1clone
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_COption_ClosureReasonZDecodeErrorZ_ok
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1ClosureReasonZDecodeErrorZ_1ok
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_COption_ClosureReasonZDecodeErrorZ_err
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1ClosureReasonZDecodeErrorZ_1err
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_COption_ClosureReasonZDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1ClosureReasonZDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_COption_ClosureReasonZDecodeErrorZ_free
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1ClosureReasonZDecodeErrorZ_1free
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1ClosureReasonZDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_COption_ClosureReasonZDecodeErrorZ_clone
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1ClosureReasonZDecodeErrorZ_1clone
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: COption_NetworkUpdateZ_some
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1NetworkUpdateZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: COption_NetworkUpdateZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_COption_1NetworkUpdateZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: COption_NetworkUpdateZ_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1SpendableOutputDescriptorZ_1free
(JNIEnv *, jclass, jlongArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: COption_EventZ_some
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_COption_1EventZ_1some
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: COption_EventZ_none
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_COption_1EventZ_1none
+ (JNIEnv *, jclass);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: COption_EventZ_free
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1EventZ_1free
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: COption_EventZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_COption_1EventZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: COption_EventZ_clone
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_COption_1EventZ_1clone
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_COption_EventZDecodeErrorZ_ok
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1EventZDecodeErrorZ_1ok
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_COption_EventZDecodeErrorZ_err
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1EventZDecodeErrorZ_1err
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_COption_EventZDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1EventZDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_COption_EventZDecodeErrorZ_free
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1EventZDecodeErrorZ_1free
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_COption_EventZDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1EventZDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_COption_EventZDecodeErrorZ_clone
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1EventZDecodeErrorZ_1clone
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CVec_MessageSendEventZ_free
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1InitFeaturesDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_InitFeaturesDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1InitFeaturesDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_InitFeaturesDecodeErrorZ_free
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NodeFeaturesDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NodeFeaturesDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NodeFeaturesDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NodeFeaturesDecodeErrorZ_free
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelFeaturesDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ChannelFeaturesDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelFeaturesDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ChannelFeaturesDecodeErrorZ_free
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceFeaturesDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_InvoiceFeaturesDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceFeaturesDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_InvoiceFeaturesDecodeErrorZ_free
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ScoringParametersDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ScoringParametersDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ScoringParametersDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ScoringParametersDecodeErrorZ_free
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ScorerDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ScorerDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ScorerDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ScorerDecodeErrorZ_free
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1DelayedPaymentOutputDescriptorDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free
/*
* Class: org_ldk_impl_bindings
- * Method: CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone
+ * Method: CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr
* Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1clone
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1clone_1ptr
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: CResult_SpendableOutputDescriptorDecodeErrorZ_ok
+ * Method: CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1StaticPaymentOutputDescriptorDecodeErrorZ_1clone
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_SpendableOutputDescriptorDecodeErrorZ_ok
* Signature: (J)J
*/
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1SpendableOutputDescriptorDecodeErrorZ_1ok
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1SpendableOutputDescriptorDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1SpendableOutputDescriptorDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_SpendableOutputDescriptorDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SpendableOutputDescriptorDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1SpendableOutputDescriptorDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_SpendableOutputDescriptorDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneNoneZ_1err
(JNIEnv *, jclass);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NoneNoneZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NoneNoneZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NoneNoneZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneNoneZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NoneNoneZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneNoneZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NoneNoneZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneNoneZ_1clone
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: C2Tuple_SignatureCVec_SignatureZZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C2Tuple_1SignatureCVec_1SignatureZZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: C2Tuple_SignatureCVec_SignatureZZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1err
(JNIEnv *, jclass);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1SignatureCVec_1SignatureZZNoneZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1SignatureNoneZ_1err
(JNIEnv *, jclass);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_SignatureNoneZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1SignatureNoneZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_SignatureNoneZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SignatureNoneZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_SignatureNoneZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1SignatureNoneZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_SignatureNoneZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1SignDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_SignDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1SignDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_SignDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SignDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_SignDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1SignDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_SignDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1RecoverableSignatureNoneZ_1err
(JNIEnv *, jclass);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_RecoverableSignatureNoneZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RecoverableSignatureNoneZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_RecoverableSignatureNoneZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RecoverableSignatureNoneZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_RecoverableSignatureNoneZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1RecoverableSignatureNoneZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_RecoverableSignatureNoneZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1CVec_1u8ZZNoneZ_1err
(JNIEnv *, jclass);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_CVec_CVec_u8ZZNoneZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1CVec_1u8ZZNoneZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_CVec_CVec_u8ZZNoneZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1CVec_1u8ZZNoneZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_CVec_CVec_u8ZZNoneZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1CVec_1u8ZZNoneZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_CVec_CVec_u8ZZNoneZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1InMemorySignerDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_InMemorySignerDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1InMemorySignerDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_InMemorySignerDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InMemorySignerDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_InMemorySignerDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1InMemorySignerDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_InMemorySignerDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1TransactionNoneZ_1err
(JNIEnv *, jclass);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_TransactionNoneZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1TransactionNoneZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_TransactionNoneZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1TransactionNoneZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_TransactionNoneZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1TransactionNoneZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_TransactionNoneZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1TransactionNoneZ_1clone
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: C2Tuple_BlockHashChannelMonitorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C2Tuple_1BlockHashChannelMonitorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: C2Tuple_BlockHashChannelMonitorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1err
(JNIEnv *, jclass, jobject);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1C2Tuple_1BlockHashChannelMonitorZZErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1u16Z_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: COption_u16Z_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_COption_1u16Z_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: COption_u16Z_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneAPIErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NoneAPIErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NoneAPIErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NoneAPIErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneAPIErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NoneAPIErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneAPIErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NoneAPIErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1_1u832APIErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult__u832APIErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1_1u832APIErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult__u832APIErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1_1u832APIErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult__u832APIErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1_1u832APIErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult__u832APIErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentSendFailureZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PaymentIdPaymentSendFailureZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentSendFailureZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_PaymentIdPaymentSendFailureZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentSendFailureZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PaymentIdPaymentSendFailureZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentSendFailureZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_PaymentIdPaymentSendFailureZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NonePaymentSendFailureZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NonePaymentSendFailureZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NonePaymentSendFailureZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NonePaymentSendFailureZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NonePaymentSendFailureZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NonePaymentSendFailureZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NonePaymentSendFailureZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NonePaymentSendFailureZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NonePaymentSendFailureZ_1clone
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: C2Tuple_PaymentHashPaymentIdZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C2Tuple_1PaymentHashPaymentIdZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: C2Tuple_PaymentHashPaymentIdZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1PaymentHashPaymentIdZPaymentSendFailureZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1PaymentHashPaymentIdZPaymentSendFailureZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1PaymentHashPaymentIdZPaymentSendFailureZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1PaymentHashPaymentIdZPaymentSendFailureZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1NetAddressZ_1free
(JNIEnv *, jclass, jlongArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: C2Tuple_PaymentHashPaymentSecretZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C2Tuple_1PaymentHashPaymentSecretZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: C2Tuple_PaymentHashPaymentSecretZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentSecretAPIErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PaymentSecretAPIErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentSecretAPIErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_PaymentSecretAPIErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentSecretAPIErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PaymentSecretAPIErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentSecretAPIErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_PaymentSecretAPIErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelManagerZDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ChannelConfigDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ChannelConfigDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ChannelConfigDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelConfigDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ChannelConfigDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1OutPointDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_OutPointDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1OutPointDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_OutPointDecodeErrorZ_free
/*
* Class: org_ldk_impl_bindings
- * Method: CResult_OutPointDecodeErrorZ_clone
+ * Method: CResult_OutPointDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1OutPointDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_OutPointDecodeErrorZ_clone
* Signature: (J)J
*/
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1OutPointDecodeErrorZ_1clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1TypeZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: COption_TypeZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_COption_1TypeZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: COption_TypeZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1TypeZDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_COption_TypeZDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1TypeZDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_COption_TypeZDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1TypeZDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_COption_TypeZDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1TypeZDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_COption_TypeZDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PaymentIdPaymentErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_PaymentIdPaymentErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PaymentIdPaymentErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PaymentIdPaymentErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_PaymentIdPaymentErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1SiPrefixNoneZ_1err
(JNIEnv *, jclass);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_SiPrefixNoneZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1SiPrefixNoneZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_SiPrefixNoneZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SiPrefixNoneZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_SiPrefixNoneZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1SiPrefixNoneZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_SiPrefixNoneZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceNoneZ_1err
(JNIEnv *, jclass);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_InvoiceNoneZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceNoneZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_InvoiceNoneZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceNoneZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_InvoiceNoneZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceNoneZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_InvoiceNoneZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1SignedRawInvoiceNoneZ_1err
(JNIEnv *, jclass);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_SignedRawInvoiceNoneZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1SignedRawInvoiceNoneZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_SignedRawInvoiceNoneZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1SignedRawInvoiceNoneZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_SignedRawInvoiceNoneZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1SignedRawInvoiceNoneZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_SignedRawInvoiceNoneZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1SignedRawInvoiceNoneZ_1clone
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C3Tuple_1RawInvoice_1u832InvoiceSignatureZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PayeePubKeyErrorZ_1err
(JNIEnv *, jclass, jobject);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PayeePubKeyErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PayeePubKeyErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_PayeePubKeyErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PayeePubKeyErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PayeePubKeyErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PayeePubKeyErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_PayeePubKeyErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PositiveTimestampCreationErrorZ_1err
(JNIEnv *, jclass, jobject);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PositiveTimestampCreationErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PositiveTimestampCreationErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_PositiveTimestampCreationErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PositiveTimestampCreationErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PositiveTimestampCreationErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PositiveTimestampCreationErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_PositiveTimestampCreationErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneSemanticErrorZ_1err
(JNIEnv *, jclass, jobject);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NoneSemanticErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NoneSemanticErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NoneSemanticErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneSemanticErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NoneSemanticErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneSemanticErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NoneSemanticErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSemanticErrorZ_1err
(JNIEnv *, jclass, jobject);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_InvoiceSemanticErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSemanticErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_InvoiceSemanticErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSemanticErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_InvoiceSemanticErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSemanticErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_InvoiceSemanticErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1DescriptionCreationErrorZ_1err
(JNIEnv *, jclass, jobject);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_DescriptionCreationErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1DescriptionCreationErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_DescriptionCreationErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1DescriptionCreationErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_DescriptionCreationErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1DescriptionCreationErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_DescriptionCreationErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ExpiryTimeCreationErrorZ_1err
(JNIEnv *, jclass, jobject);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ExpiryTimeCreationErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ExpiryTimeCreationErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ExpiryTimeCreationErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ExpiryTimeCreationErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ExpiryTimeCreationErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ExpiryTimeCreationErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ExpiryTimeCreationErrorZ_clone
* Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ExpiryTimeCreationErrorZ_1clone
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ExpiryTimeCreationErrorZ_1clone
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PrivateRouteCreationErrorZ_ok
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PrivateRouteCreationErrorZ_1ok
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PrivateRouteCreationErrorZ_err
+ * Signature: (Lorg/ldk/enums/CreationError;)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PrivateRouteCreationErrorZ_1err
+ (JNIEnv *, jclass, jobject);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PrivateRouteCreationErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PrivateRouteCreationErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PrivateRouteCreationErrorZ_free
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PrivateRouteCreationErrorZ_1free
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PrivateRouteCreationErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PrivateRouteCreationErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PrivateRouteCreationErrorZ_clone
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PrivateRouteCreationErrorZ_1clone
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_StringErrorZ_ok
+ * Signature: (Ljava/lang/String;)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1StringErrorZ_1ok
+ (JNIEnv *, jclass, jstring);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_StringErrorZ_err
+ * Signature: (Lorg/ldk/enums/Secp256k1Error;)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1StringErrorZ_1err
+ (JNIEnv *, jclass, jobject);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_StringErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1StringErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_StringErrorZ_free
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1StringErrorZ_1free
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ChannelMonitorUpdateDecodeErrorZ_ok
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1ok
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ChannelMonitorUpdateDecodeErrorZ_err
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1err
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ChannelMonitorUpdateDecodeErrorZ_free
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1free
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ChannelMonitorUpdateDecodeErrorZ_clone
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1clone
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: CResult_PrivateRouteCreationErrorZ_ok
+ * Method: COption_MonitorEventZ_some
* Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PrivateRouteCreationErrorZ_1ok
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_COption_1MonitorEventZ_1some
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: CResult_PrivateRouteCreationErrorZ_err
- * Signature: (Lorg/ldk/enums/CreationError;)J
+ * Method: COption_MonitorEventZ_none
+ * Signature: ()J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PrivateRouteCreationErrorZ_1err
- (JNIEnv *, jclass, jobject);
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_COption_1MonitorEventZ_1none
+ (JNIEnv *, jclass);
/*
* Class: org_ldk_impl_bindings
- * Method: CResult_PrivateRouteCreationErrorZ_free
+ * Method: COption_MonitorEventZ_free
* Signature: (J)V
*/
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PrivateRouteCreationErrorZ_1free
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1MonitorEventZ_1free
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: CResult_PrivateRouteCreationErrorZ_clone
+ * Method: COption_MonitorEventZ_clone_ptr
* Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PrivateRouteCreationErrorZ_1clone
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_COption_1MonitorEventZ_1clone_1ptr
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: CResult_StringErrorZ_ok
- * Signature: (Ljava/lang/String;)J
+ * Method: COption_MonitorEventZ_clone
+ * Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1StringErrorZ_1ok
- (JNIEnv *, jclass, jstring);
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_COption_1MonitorEventZ_1clone
+ (JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: CResult_StringErrorZ_err
- * Signature: (Lorg/ldk/enums/Secp256k1Error;)J
+ * Method: CResult_COption_MonitorEventZDecodeErrorZ_ok
+ * Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1StringErrorZ_1err
- (JNIEnv *, jclass, jobject);
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1MonitorEventZDecodeErrorZ_1ok
+ (JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: CResult_StringErrorZ_free
- * Signature: (J)V
+ * Method: CResult_COption_MonitorEventZDecodeErrorZ_err
+ * Signature: (J)J
*/
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1StringErrorZ_1free
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1MonitorEventZDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: CResult_ChannelMonitorUpdateDecodeErrorZ_ok
- * Signature: (J)J
+ * Method: CResult_COption_MonitorEventZDecodeErrorZ_is_ok
+ * Signature: (J)Z
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1ok
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1MonitorEventZDecodeErrorZ_1is_1ok
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: CResult_ChannelMonitorUpdateDecodeErrorZ_err
- * Signature: (J)J
+ * Method: CResult_COption_MonitorEventZDecodeErrorZ_free
+ * Signature: (J)V
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1err
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1MonitorEventZDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: CResult_ChannelMonitorUpdateDecodeErrorZ_free
- * Signature: (J)V
+ * Method: CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr
+ * Signature: (J)J
*/
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1free
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1MonitorEventZDecodeErrorZ_1clone_1ptr
(JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
- * Method: CResult_ChannelMonitorUpdateDecodeErrorZ_clone
+ * Method: CResult_COption_MonitorEventZDecodeErrorZ_clone
* Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelMonitorUpdateDecodeErrorZ_1clone
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1MonitorEventZDecodeErrorZ_1clone
(JNIEnv *, jclass, jlong);
/*
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCUpdateDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_HTLCUpdateDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCUpdateDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_HTLCUpdateDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCUpdateDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_HTLCUpdateDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1HTLCUpdateDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_HTLCUpdateDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneMonitorUpdateErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NoneMonitorUpdateErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NoneMonitorUpdateErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NoneMonitorUpdateErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneMonitorUpdateErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NoneMonitorUpdateErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneMonitorUpdateErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NoneMonitorUpdateErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneMonitorUpdateErrorZ_1clone
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: C2Tuple_OutPointScriptZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C2Tuple_1OutPointScriptZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: C2Tuple_OutPointScriptZ_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_C2Tuple_1OutPointScriptZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: C2Tuple_u32ScriptZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32ScriptZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: C2Tuple_u32ScriptZ_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1C2Tuple_1u32ScriptZZ_1free
(JNIEnv *, jclass, jlongArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C2Tuple_1TxidCVec_1C2Tuple_1u32ScriptZZZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1TransactionZ_1free
(JNIEnv *, jclass, jobjectArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: C2Tuple_u32TxOutZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C2Tuple_1u32TxOutZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: C2Tuple_u32TxOutZ_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CVec_1C2Tuple_1u32TxOutZZ_1free
(JNIEnv *, jclass, jlongArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C2Tuple_1TxidCVec_1C2Tuple_1u32TxOutZZZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1C2Tuple_1BlockHashChannelMonitorZDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NoneLightningErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NoneLightningErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NoneLightningErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NoneLightningErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NoneLightningErrorZ_1clone
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: C2Tuple_PublicKeyTypeZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C2Tuple_1PublicKeyTypeZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: C2Tuple_PublicKeyTypeZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_boolLightningErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_boolLightningErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_boolLightningErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_boolLightningErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1boolLightningErrorZ_1clone
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_C3Tuple_1ChannelAnnouncementChannelUpdateChannelUpdateZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1u8ZPeerHandleErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_CVec_u8ZPeerHandleErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1u8ZPeerHandleErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_CVec_u8ZPeerHandleErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1u8ZPeerHandleErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1CVec_1u8ZPeerHandleErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_CVec_u8ZPeerHandleErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NonePeerHandleErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NonePeerHandleErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NonePeerHandleErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NonePeerHandleErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NonePeerHandleErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NonePeerHandleErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NonePeerHandleErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NonePeerHandleErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1boolPeerHandleErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_boolPeerHandleErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1boolPeerHandleErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_boolPeerHandleErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1boolPeerHandleErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_boolPeerHandleErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1boolPeerHandleErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_boolPeerHandleErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NodeIdDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NodeIdDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NodeIdDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NodeIdDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeIdDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NodeIdDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NodeIdDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NodeIdDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NodeIdDecodeErrorZ_1clone
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_COption_NetworkUpdateZDecodeErrorZ_ok
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1NetworkUpdateZDecodeErrorZ_1ok
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_COption_NetworkUpdateZDecodeErrorZ_err
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1NetworkUpdateZDecodeErrorZ_1err
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1NetworkUpdateZDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_COption_NetworkUpdateZDecodeErrorZ_free
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1NetworkUpdateZDecodeErrorZ_1free
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1NetworkUpdateZDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_COption_NetworkUpdateZDecodeErrorZ_clone
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1COption_1NetworkUpdateZDecodeErrorZ_1clone
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: COption_AccessZ_some
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1DirectionalChannelInfoDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_DirectionalChannelInfoDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1DirectionalChannelInfoDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_DirectionalChannelInfoDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1DirectionalChannelInfoDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1DirectionalChannelInfoDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_DirectionalChannelInfoDecodeErrorZ_clone
/*
* Class: org_ldk_impl_bindings
- * Method: CResult_ChannelInfoDecodeErrorZ_free
- * Signature: (J)V
+ * Method: CResult_ChannelInfoDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelInfoDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ChannelInfoDecodeErrorZ_free
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelInfoDecodeErrorZ_1free
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ChannelInfoDecodeErrorZ_clone_ptr
+ * Signature: (J)J
*/
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelInfoDecodeErrorZ_1free
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelInfoDecodeErrorZ_1clone_1ptr
(JNIEnv *, jclass, jlong);
/*
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1RoutingFeesDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_RoutingFeesDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RoutingFeesDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_RoutingFeesDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RoutingFeesDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_RoutingFeesDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1RoutingFeesDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_RoutingFeesDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementInfoDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementInfoDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NodeAnnouncementInfoDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementInfoDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementInfoDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NodeAnnouncementInfoDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NodeInfoDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NodeInfoDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NodeInfoDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NodeInfoDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeInfoDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NodeInfoDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NodeInfoDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NodeInfoDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NetworkGraphDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NetworkGraphDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NetworkGraphDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NetworkGraphDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NetworkGraphDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NetworkGraphDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NetworkGraphDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NetworkGraphDecodeErrorZ_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_COption_1CVec_1NetAddressZZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: COption_CVec_NetAddressZZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_COption_1CVec_1NetAddressZZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: COption_CVec_NetAddressZZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NetAddressDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NetAddressDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NetAddressDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NetAddressDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NetAddressDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1AcceptChannelDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_AcceptChannelDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1AcceptChannelDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_AcceptChannelDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1AcceptChannelDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_AcceptChannelDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1AcceptChannelDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_AcceptChannelDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1AnnouncementSignaturesDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_AnnouncementSignaturesDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1AnnouncementSignaturesDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_AnnouncementSignaturesDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1AnnouncementSignaturesDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1AnnouncementSignaturesDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_AnnouncementSignaturesDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelReestablishDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ChannelReestablishDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelReestablishDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ChannelReestablishDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelReestablishDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ChannelReestablishDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelReestablishDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ChannelReestablishDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ClosingSignedDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ClosingSignedDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ClosingSignedDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ClosingSignedDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedFeeRangeDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedFeeRangeDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ClosingSignedFeeRangeDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedFeeRangeDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ClosingSignedFeeRangeDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ClosingSignedFeeRangeDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentSignedDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_CommitmentSignedDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentSignedDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_CommitmentSignedDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentSignedDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_CommitmentSignedDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1CommitmentSignedDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_CommitmentSignedDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1FundingCreatedDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_FundingCreatedDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1FundingCreatedDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_FundingCreatedDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1FundingCreatedDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_FundingCreatedDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1FundingCreatedDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_FundingCreatedDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1FundingSignedDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_FundingSignedDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1FundingSignedDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_FundingSignedDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1FundingSignedDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_FundingSignedDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1FundingSignedDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_FundingSignedDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1FundingLockedDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_FundingLockedDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1FundingLockedDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_FundingLockedDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1FundingLockedDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_FundingLockedDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1FundingLockedDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_FundingLockedDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1InitDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_InitDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1InitDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_InitDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InitDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_InitDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1InitDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_InitDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1OpenChannelDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_OpenChannelDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1OpenChannelDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_OpenChannelDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1OpenChannelDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_OpenChannelDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1OpenChannelDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_OpenChannelDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1RevokeAndACKDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_RevokeAndACKDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1RevokeAndACKDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_RevokeAndACKDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1RevokeAndACKDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_RevokeAndACKDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1RevokeAndACKDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_RevokeAndACKDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ShutdownDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ShutdownDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ShutdownDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ShutdownDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ShutdownDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailHTLCDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_UpdateFailHTLCDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailHTLCDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_UpdateFailHTLCDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailHTLCDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailHTLCDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_UpdateFailHTLCDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailMalformedHTLCDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailMalformedHTLCDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_UpdateFailMalformedHTLCDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailMalformedHTLCDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFailMalformedHTLCDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone
* Method: CResult_UpdateFeeDecodeErrorZ_err
* Signature: (J)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFeeDecodeErrorZ_1err
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFeeDecodeErrorZ_1err
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_UpdateFeeDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFeeDecodeErrorZ_1is_1ok
(JNIEnv *, jclass, jlong);
/*
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFeeDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_UpdateFeeDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFeeDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_UpdateFeeDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFulfillHTLCDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFulfillHTLCDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_UpdateFulfillHTLCDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFulfillHTLCDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateFulfillHTLCDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_UpdateFulfillHTLCDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateAddHTLCDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_UpdateAddHTLCDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateAddHTLCDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_UpdateAddHTLCDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateAddHTLCDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1UpdateAddHTLCDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_UpdateAddHTLCDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PingDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PingDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PingDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_PingDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PingDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PingDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PingDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_PingDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PongDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PongDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1PongDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_PongDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1PongDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_PongDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1PongDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_PongDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelAnnouncementDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelAnnouncementDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_UnsignedChannelAnnouncementDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelAnnouncementDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelAnnouncementDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelAnnouncementDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ChannelAnnouncementDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelAnnouncementDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ChannelAnnouncementDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelAnnouncementDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelAnnouncementDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ChannelAnnouncementDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelUpdateDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelUpdateDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_UnsignedChannelUpdateDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelUpdateDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedChannelUpdateDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_UnsignedChannelUpdateDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelUpdateDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ChannelUpdateDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelUpdateDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ChannelUpdateDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelUpdateDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ChannelUpdateDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ChannelUpdateDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ChannelUpdateDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ErrorMessageDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ErrorMessageDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ErrorMessageDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ErrorMessageDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ErrorMessageDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ErrorMessageDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ErrorMessageDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ErrorMessageDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedNodeAnnouncementDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedNodeAnnouncementDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_UnsignedNodeAnnouncementDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedNodeAnnouncementDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1UnsignedNodeAnnouncementDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NodeAnnouncementDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NodeAnnouncementDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_NodeAnnouncementDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1NodeAnnouncementDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_NodeAnnouncementDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1QueryShortChannelIdsDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_QueryShortChannelIdsDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1QueryShortChannelIdsDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_QueryShortChannelIdsDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1QueryShortChannelIdsDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1QueryShortChannelIdsDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_QueryShortChannelIdsDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyShortChannelIdsEndDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyShortChannelIdsEndDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ReplyShortChannelIdsEndDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyShortChannelIdsEndDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyShortChannelIdsEndDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1QueryChannelRangeDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_QueryChannelRangeDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1QueryChannelRangeDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_QueryChannelRangeDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1QueryChannelRangeDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_QueryChannelRangeDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1QueryChannelRangeDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_QueryChannelRangeDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyChannelRangeDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ReplyChannelRangeDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyChannelRangeDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ReplyChannelRangeDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyChannelRangeDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1ReplyChannelRangeDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_ReplyChannelRangeDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1GossipTimestampFilterDecodeErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_GossipTimestampFilterDecodeErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1GossipTimestampFilterDecodeErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_GossipTimestampFilterDecodeErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1GossipTimestampFilterDecodeErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1GossipTimestampFilterDecodeErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_GossipTimestampFilterDecodeErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSignOrCreationErrorZ_1err
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_InvoiceSignOrCreationErrorZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSignOrCreationErrorZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_InvoiceSignOrCreationErrorZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSignOrCreationErrorZ_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_InvoiceSignOrCreationErrorZ_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1InvoiceSignOrCreationErrorZ_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_InvoiceSignOrCreationErrorZ_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CResult_1LockedChannelMonitorNoneZ_1err
(JNIEnv *, jclass);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CResult_LockedChannelMonitorNoneZ_is_ok
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_CResult_1LockedChannelMonitorNoneZ_1is_1ok
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CResult_LockedChannelMonitorNoneZ_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PaymentPurpose_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: PaymentPurpose_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_PaymentPurpose_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: PaymentPurpose_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ClosureReason_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ClosureReason_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ClosureReason_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ClosureReason_clone
JNIEXPORT jbyteArray JNICALL Java_org_ldk_impl_bindings_ClosureReason_1write
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ClosureReason_read
+ * Signature: ([B)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ClosureReason_1read
+ (JNIEnv *, jclass, jbyteArray);
+
/*
* Class: org_ldk_impl_bindings
* Method: Event_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Event_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Event_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Event_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: Event_clone
/*
* Class: org_ldk_impl_bindings
- * Method: MessageSendEvent_free
- * Signature: (J)V
+ * Method: Event_read
+ * Signature: ([B)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Event_1read
+ (JNIEnv *, jclass, jbyteArray);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: MessageSendEvent_free
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MessageSendEvent_1free
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: MessageSendEvent_clone_ptr
+ * Signature: (J)J
*/
-JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MessageSendEvent_1free
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_MessageSendEvent_1clone_1ptr
(JNIEnv *, jclass, jlong);
/*
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_APIError_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: APIError_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_APIError_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: APIError_clone
JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_Level_1max
(JNIEnv *, jclass);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Record_free
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Record_1free
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Record_get_level
+ * Signature: (J)Lorg/ldk/enums/Level;
+ */
+JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_Record_1get_1level
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Record_set_level
+ * Signature: (JLorg/ldk/enums/Level;)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Record_1set_1level
+ (JNIEnv *, jclass, jlong, jobject);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Record_get_args
+ * Signature: (J)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_Record_1get_1args
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Record_set_args
+ * Signature: (JLjava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Record_1set_1args
+ (JNIEnv *, jclass, jlong, jstring);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Record_get_module_path
+ * Signature: (J)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_Record_1get_1module_1path
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Record_set_module_path
+ * Signature: (JLjava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Record_1set_1module_1path
+ (JNIEnv *, jclass, jlong, jstring);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Record_get_file
+ * Signature: (J)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_Record_1get_1file
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Record_set_file
+ * Signature: (JLjava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Record_1set_1file
+ (JNIEnv *, jclass, jlong, jstring);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Record_get_line
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_ldk_impl_bindings_Record_1get_1line
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Record_set_line
+ * Signature: (JI)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Record_1set_1line
+ (JNIEnv *, jclass, jlong, jint);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Record_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Record_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Record_clone
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Record_1clone
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: Logger_free
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1new
(JNIEnv *, jclass, jint, jshort, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ChannelHandshakeConfig_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeConfig_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ChannelHandshakeConfig_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1new
(JNIEnv *, jclass, jlong, jlong, jlong, jlong, jshort, jint, jboolean, jshort);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ChannelHandshakeLimits_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelHandshakeLimits_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ChannelHandshakeLimits_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1new
(JNIEnv *, jclass, jint, jint, jshort, jboolean, jboolean, jlong, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ChannelConfig_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelConfig_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ChannelConfig_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_UserConfig_1new
(JNIEnv *, jclass, jlong, jlong, jlong, jboolean);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: UserConfig_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_UserConfig_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: UserConfig_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_BestBlock_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: BestBlock_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_BestBlock_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: BestBlock_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_WatchedOutput_1new
(JNIEnv *, jclass, jbyteArray, jlong, jbyteArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: WatchedOutput_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_WatchedOutput_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: WatchedOutput_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MonitorUpdateId_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: MonitorUpdateId_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_MonitorUpdateId_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: MonitorUpdateId_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMonitorUpdate_1set_1update_1id
(JNIEnv *, jclass, jlong, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ChannelMonitorUpdate_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelMonitorUpdate_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ChannelMonitorUpdate_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_MonitorUpdateError_1new
(JNIEnv *, jclass, jstring);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: MonitorUpdateError_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_MonitorUpdateError_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: MonitorUpdateError_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_MonitorEvent_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: MonitorEvent_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_MonitorEvent_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: MonitorEvent_clone
JNIEXPORT jbyteArray JNICALL Java_org_ldk_impl_bindings_MonitorEvent_1write
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: MonitorEvent_read
+ * Signature: ([B)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_MonitorEvent_1read
+ (JNIEnv *, jclass, jbyteArray);
+
/*
* Class: org_ldk_impl_bindings
* Method: HTLCUpdate_free
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HTLCUpdate_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: HTLCUpdate_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_HTLCUpdate_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: HTLCUpdate_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Balance_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Balance_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Balance_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: Balance_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ChannelMonitor_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelMonitor_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ChannelMonitor_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_OutPoint_1new
(JNIEnv *, jclass, jbyteArray, jshort);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: OutPoint_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_OutPoint_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: OutPoint_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1new
(JNIEnv *, jclass, jlong, jbyteArray, jshort, jlong, jbyteArray, jbyteArray, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: DelayedPaymentOutputDescriptor_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_DelayedPaymentOutputDescriptor_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: DelayedPaymentOutputDescriptor_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1new
(JNIEnv *, jclass, jlong, jlong, jbyteArray, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: StaticPaymentOutputDescriptor_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_StaticPaymentOutputDescriptor_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: StaticPaymentOutputDescriptor_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_SpendableOutputDescriptor_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: SpendableOutputDescriptor_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_SpendableOutputDescriptor_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: SpendableOutputDescriptor_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_BaseSign_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Sign_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Sign_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: Sign_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1set_1commitment_1seed
(JNIEnv *, jclass, jlong, jbyteArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: InMemorySigner_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_InMemorySigner_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: InMemorySigner_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChainParameters_1new
(JNIEnv *, jclass, jobject, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ChainParameters_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChainParameters_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ChainParameters_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CounterpartyForwardingInfo_1new
(JNIEnv *, jclass, jint, jint, jshort);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CounterpartyForwardingInfo_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CounterpartyForwardingInfo_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CounterpartyForwardingInfo_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelCounterparty_1new
(JNIEnv *, jclass, jbyteArray, jlong, jlong, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ChannelCounterparty_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelCounterparty_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ChannelCounterparty_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1new
(JNIEnv *, jclass, jbyteArray, jlong, jlong, jlong, jlong, jlong, jlong, jlong, jlong, jlong, jlong, jboolean, jboolean, jboolean, jboolean);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ChannelDetails_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelDetails_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ChannelDetails_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PaymentSendFailure_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: PaymentSendFailure_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_PaymentSendFailure_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: PaymentSendFailure_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_DecodeError_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: DecodeError_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_DecodeError_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: DecodeError_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Init_1new
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Init_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Init_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: Init_clone
* Method: ErrorMessage_new
* Signature: ([BLjava/lang/String;)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1new
- (JNIEnv *, jclass, jbyteArray, jstring);
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1new
+ (JNIEnv *, jclass, jbyteArray, jstring);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ErrorMessage_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ErrorMessage_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Ping_1new
(JNIEnv *, jclass, jshort, jshort);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Ping_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Ping_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: Ping_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Pong_1new
(JNIEnv *, jclass, jshort);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Pong_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Pong_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: Pong_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_OpenChannel_1set_1channel_1flags
(JNIEnv *, jclass, jlong, jbyte);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: OpenChannel_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_OpenChannel_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: OpenChannel_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1set_1first_1per_1commitment_1point
(JNIEnv *, jclass, jlong, jbyteArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: AcceptChannel_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_AcceptChannel_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: AcceptChannel_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_FundingCreated_1new
(JNIEnv *, jclass, jbyteArray, jbyteArray, jshort, jbyteArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: FundingCreated_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_FundingCreated_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: FundingCreated_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_FundingSigned_1new
(JNIEnv *, jclass, jbyteArray, jbyteArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: FundingSigned_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_FundingSigned_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: FundingSigned_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_FundingLocked_1new
(JNIEnv *, jclass, jbyteArray, jbyteArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: FundingLocked_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_FundingLocked_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: FundingLocked_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Shutdown_1new
(JNIEnv *, jclass, jbyteArray, jbyteArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Shutdown_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Shutdown_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: Shutdown_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ClosingSignedFeeRange_1new
(JNIEnv *, jclass, jlong, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ClosingSignedFeeRange_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ClosingSignedFeeRange_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ClosingSignedFeeRange_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1new
(JNIEnv *, jclass, jbyteArray, jlong, jbyteArray, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ClosingSigned_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ClosingSigned_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ClosingSigned_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1set_1cltv_1expiry
(JNIEnv *, jclass, jlong, jint);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: UpdateAddHTLC_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_UpdateAddHTLC_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: UpdateAddHTLC_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1new
(JNIEnv *, jclass, jbyteArray, jlong, jbyteArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: UpdateFulfillHTLC_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_UpdateFulfillHTLC_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: UpdateFulfillHTLC_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFailHTLC_1set_1htlc_1id
(JNIEnv *, jclass, jlong, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: UpdateFailHTLC_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_UpdateFailHTLC_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: UpdateFailHTLC_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1set_1failure_1code
(JNIEnv *, jclass, jlong, jshort);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: UpdateFailMalformedHTLC_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_UpdateFailMalformedHTLC_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: UpdateFailMalformedHTLC_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1new
(JNIEnv *, jclass, jbyteArray, jbyteArray, jobjectArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CommitmentSigned_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CommitmentSigned_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CommitmentSigned_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1new
(JNIEnv *, jclass, jbyteArray, jbyteArray, jbyteArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: RevokeAndACK_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_RevokeAndACK_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: RevokeAndACK_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_UpdateFee_1new
(JNIEnv *, jclass, jbyteArray, jint);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: UpdateFee_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_UpdateFee_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: UpdateFee_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_DataLossProtect_1new
(JNIEnv *, jclass, jbyteArray, jbyteArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: DataLossProtect_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_DataLossProtect_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: DataLossProtect_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1set_1next_1remote_1commitment_1number
(JNIEnv *, jclass, jlong, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ChannelReestablish_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelReestablish_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ChannelReestablish_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1new
(JNIEnv *, jclass, jbyteArray, jlong, jbyteArray, jbyteArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: AnnouncementSignatures_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_AnnouncementSignatures_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: AnnouncementSignatures_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NetAddress_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: NetAddress_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_NetAddress_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: NetAddress_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1set_1addresses
(JNIEnv *, jclass, jlong, jlongArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: UnsignedNodeAnnouncement_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_UnsignedNodeAnnouncement_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: UnsignedNodeAnnouncement_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1new
(JNIEnv *, jclass, jbyteArray, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: NodeAnnouncement_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_NodeAnnouncement_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: NodeAnnouncement_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1set_1bitcoin_1key_12
(JNIEnv *, jclass, jlong, jbyteArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: UnsignedChannelAnnouncement_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_UnsignedChannelAnnouncement_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: UnsignedChannelAnnouncement_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1new
(JNIEnv *, jclass, jbyteArray, jbyteArray, jbyteArray, jbyteArray, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ChannelAnnouncement_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelAnnouncement_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ChannelAnnouncement_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1set_1fee_1proportional_1millionths
(JNIEnv *, jclass, jlong, jint);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: UnsignedChannelUpdate_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_UnsignedChannelUpdate_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: UnsignedChannelUpdate_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1new
(JNIEnv *, jclass, jbyteArray, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ChannelUpdate_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelUpdate_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ChannelUpdate_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1new
(JNIEnv *, jclass, jbyteArray, jint, jint);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: QueryChannelRange_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_QueryChannelRange_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: QueryChannelRange_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1new
(JNIEnv *, jclass, jbyteArray, jint, jint, jboolean, jlongArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ReplyChannelRange_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ReplyChannelRange_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ReplyChannelRange_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_QueryShortChannelIds_1new
(JNIEnv *, jclass, jbyteArray, jlongArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: QueryShortChannelIds_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_QueryShortChannelIds_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: QueryShortChannelIds_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1new
(JNIEnv *, jclass, jbyteArray, jboolean);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ReplyShortChannelIdsEnd_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ReplyShortChannelIdsEnd_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ReplyShortChannelIdsEnd_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1new
(JNIEnv *, jclass, jbyteArray, jint, jint);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: GossipTimestampFilter_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_GossipTimestampFilter_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: GossipTimestampFilter_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ErrorAction_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ErrorAction_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ErrorAction_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ErrorAction_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LightningError_1new
(JNIEnv *, jclass, jstring, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: LightningError_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_LightningError_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: LightningError_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1new
(JNIEnv *, jclass, jlongArray, jlongArray, jlongArray, jlongArray, jlong, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CommitmentUpdate_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CommitmentUpdate_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CommitmentUpdate_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_MessageHandler_1new
(JNIEnv *, jclass, jlong, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: SocketDescriptor_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_SocketDescriptor_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: SocketDescriptor_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_PeerHandleError_1new
(JNIEnv *, jclass, jboolean);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: PeerHandleError_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_PeerHandleError_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: PeerHandleError_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1new
(JNIEnv *, jclass, jbyteArray, jbyteArray, jbyteArray, jbyteArray, jbyteArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: TxCreationKeys_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_TxCreationKeys_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: TxCreationKeys_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1new
(JNIEnv *, jclass, jbyteArray, jbyteArray, jbyteArray, jbyteArray, jbyteArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ChannelPublicKeys_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelPublicKeys_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ChannelPublicKeys_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1new
(JNIEnv *, jclass, jboolean, jlong, jint, jbyteArray, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: HTLCOutputInCommitment_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_HTLCOutputInCommitment_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: HTLCOutputInCommitment_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1new
(JNIEnv *, jclass, jlong, jshort, jboolean, jlong, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ChannelTransactionParameters_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelTransactionParameters_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ChannelTransactionParameters_clone
* Method: CounterpartyChannelTransactionParameters_new
* Signature: (JS)J
*/
-JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1new
- (JNIEnv *, jclass, jlong, jshort);
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1new
+ (JNIEnv *, jclass, jlong, jshort);
+
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CounterpartyChannelTransactionParameters_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CounterpartyChannelTransactionParameters_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
/*
* Class: org_ldk_impl_bindings
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_HolderCommitmentTransaction_1set_1counterparty_1htlc_1sigs
(JNIEnv *, jclass, jlong, jobjectArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: HolderCommitmentTransaction_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_HolderCommitmentTransaction_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: HolderCommitmentTransaction_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1new
(JNIEnv *, jclass, jbyteArray, jbyteArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: BuiltCommitmentTransaction_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_BuiltCommitmentTransaction_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: BuiltCommitmentTransaction_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ClosingTransaction_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ClosingTransaction_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ClosingTransaction_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ClosingTransaction_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: CommitmentTransaction_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_CommitmentTransaction_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: CommitmentTransaction_clone
JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_InvoiceFeatures_1eq
(JNIEnv *, jclass, jlong, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: InitFeatures_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_InitFeatures_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: InitFeatures_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_InitFeatures_1clone
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: NodeFeatures_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: NodeFeatures_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_NodeFeatures_1clone
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ChannelFeatures_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelFeatures_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ChannelFeatures_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelFeatures_1clone
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: InvoiceFeatures_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_InvoiceFeatures_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: InvoiceFeatures_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ShutdownScript_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ShutdownScript_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ShutdownScript_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ShutdownScript_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_InvalidShutdownScript_1new
(JNIEnv *, jclass, jbyteArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: InvalidShutdownScript_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_InvalidShutdownScript_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: InvalidShutdownScript_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_CustomMessageReader_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Type_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Type_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: Type_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NodeId_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: NodeId_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_NodeId_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: NodeId_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: NetworkGraph_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_NetworkGraph_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: NetworkGraph_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_NetworkUpdate_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: NetworkUpdate_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_NetworkUpdate_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: NetworkUpdate_clone
JNIEXPORT jbyteArray JNICALL Java_org_ldk_impl_bindings_NetworkUpdate_1write
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: NetworkUpdate_read
+ * Signature: ([B)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_NetworkUpdate_1read
+ (JNIEnv *, jclass, jbyteArray);
+
/*
* Class: org_ldk_impl_bindings
* Method: NetGraphMsgHandler_as_EventHandler
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1new
(JNIEnv *, jclass, jint, jboolean, jshort, jlong, jlong, jlong, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: DirectionalChannelInfo_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_DirectionalChannelInfo_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: DirectionalChannelInfo_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1new
(JNIEnv *, jclass, jlong, jlong, jlong, jlong, jlong, jlong, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ChannelInfo_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ChannelInfo_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ChannelInfo_clone
JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_RoutingFees_1eq
(JNIEnv *, jclass, jlong, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: RoutingFees_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_RoutingFees_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: RoutingFees_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1new
(JNIEnv *, jclass, jlong, jint, jbyteArray, jbyteArray, jlongArray, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: NodeAnnouncementInfo_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_NodeAnnouncementInfo_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: NodeAnnouncementInfo_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_NodeInfo_1new
(JNIEnv *, jclass, jlongArray, jlong, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: NodeInfo_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_NodeInfo_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: NodeInfo_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_RouteHop_1new
(JNIEnv *, jclass, jbyteArray, jlong, jlong, jlong, jlong, jint);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: RouteHop_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_RouteHop_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: RouteHop_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Route_1new
(JNIEnv *, jclass, jobjectArray, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Route_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Route_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: Route_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_RouteParameters_1new
(JNIEnv *, jclass, jlong, jlong, jint);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: RouteParameters_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_RouteParameters_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: RouteParameters_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Payee_1new
(JNIEnv *, jclass, jbyteArray, jlong, jlongArray, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Payee_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Payee_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: Payee_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_RouteHint_1new
(JNIEnv *, jclass, jlongArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: RouteHint_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_RouteHint_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: RouteHint_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_RouteHintHop_1new
(JNIEnv *, jclass, jbyteArray, jlong, jlong, jshort, jlong, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: RouteHintHop_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_RouteHintHop_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: RouteHintHop_clone
JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_Invoice_1eq
(JNIEnv *, jclass, jlong, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Invoice_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Invoice_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: Invoice_clone
JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_SignedRawInvoice_1eq
(JNIEnv *, jclass, jlong, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: SignedRawInvoice_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_SignedRawInvoice_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: SignedRawInvoice_clone
JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_RawInvoice_1eq
(JNIEnv *, jclass, jlong, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: RawInvoice_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_RawInvoice_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: RawInvoice_clone
JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_RawDataPart_1eq
(JNIEnv *, jclass, jlong, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: RawDataPart_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_RawDataPart_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: RawDataPart_clone
JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_PositiveTimestamp_1eq
(JNIEnv *, jclass, jlong, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: PositiveTimestamp_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_PositiveTimestamp_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: PositiveTimestamp_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Sha256_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Sha256_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Sha256_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: Sha256_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Description_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Description_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Description_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: Description_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_PayeePubKey_1new
(JNIEnv *, jclass, jbyteArray);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: PayeePubKey_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_PayeePubKey_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: PayeePubKey_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_ExpiryTime_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: ExpiryTime_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_ExpiryTime_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: ExpiryTime_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_MinFinalCltvExpiry_1new
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: MinFinalCltvExpiry_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_MinFinalCltvExpiry_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: MinFinalCltvExpiry_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_Fallback_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: Fallback_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_Fallback_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: Fallback_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_InvoiceSignature_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: InvoiceSignature_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_InvoiceSignature_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: InvoiceSignature_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PrivateRoute_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: PrivateRoute_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_PrivateRoute_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: PrivateRoute_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_SignOrCreationError_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: SignOrCreationError_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_SignOrCreationError_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: SignOrCreationError_clone
JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_RetryAttempts_1new
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: RetryAttempts_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_RetryAttempts_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: RetryAttempts_clone
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PaymentError_1free
(JNIEnv *, jclass, jlong);
+/*
+ * Class: org_ldk_impl_bindings
+ * Method: PaymentError_clone_ptr
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_PaymentError_1clone_1ptr
+ (JNIEnv *, jclass, jlong);
+
/*
* Class: org_ldk_impl_bindings
* Method: PaymentError_clone
import org.ldk.batteries.NioPeerHandler;
import org.ldk.enums.AccessError;
import org.ldk.enums.Currency;
+import org.ldk.enums.Level;
import org.ldk.enums.Network;
import org.ldk.structs.*;
import org.ldk.util.TwoTuple;
NetGraphMsgHandler route_handler;
final Watch chain_watch;
final HashSet<String> filter_additions;
- final Option_FilterZ filter;
+ Option_FilterZ filter;
ChannelManager chan_manager;
PeerManager peer_manager;
final HashMap<String, ChannelMonitor> monitors; // Wow I forgot just how terrible Java is - we can't put a byte array here.
}
private Peer(Object _dummy, byte seed) {
- logger = Logger.new_impl((String arg) -> System.out.println(seed + ": " + arg));
+ logger = Logger.new_impl((Record arg)->{
+ if (arg.get_level() == Level.LDKLevel_Error)
+ System.err.println(seed + ": " + arg.get_module_path() + " - " + arg.get_args());
+ else
+ System.out.println(seed + ": " + arg.get_module_path() + " - " + arg.get_args());
+ });
fee_estimator = FeeEstimator.new_impl((confirmation_target -> 253));
tx_broadcaster = BroadcasterInterface.new_impl(tx -> {
synchronized (broadcast_set) {
}
this.node_id = chan_manager.get_our_node_id();
+ this.filter = null;
bind_nio();
System.gc();
}
filter_nullable = ((Option_FilterZ.Some) this.filter).some;
}
if (use_ignore_handler) {
- this.constructor = new ChannelManagerConstructor(serialized, monitors, this.keys_interface,
- this.fee_estimator, this.chain_monitor, filter_nullable, null, this.tx_broadcaster, this.logger);
+ this.constructor = new ChannelManagerConstructor(serialized, monitors, UserConfig.with_default(),
+ this.keys_interface, this.fee_estimator, this.chain_monitor, filter_nullable,
+ null, this.tx_broadcaster, this.logger);
} else {
- this.constructor = new ChannelManagerConstructor(serialized, monitors, this.keys_interface,
- this.fee_estimator, this.chain_monitor, filter_nullable, this.router, this.tx_broadcaster, this.logger);
+ this.constructor = new ChannelManagerConstructor(serialized, monitors, UserConfig.with_default(),
+ this.keys_interface, this.fee_estimator, this.chain_monitor, filter_nullable,
+ this.router, this.tx_broadcaster, this.logger);
}
LockableScore scorer = null;
if (use_invoice_payer) { scorer = LockableScore.of(Scorer.with_default().as_Score()); }
// the ChannelSigner.
this.ptr_to = orig.chan_manager;
}
+ this.filter = null;
}
TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[] connect_block(Block b, int height, long expected_monitor_update_len) {
t.interrupt();
+ state.peer1.router.write();
+
// Construct the only Option_Enum::Variant(OpaqueStruct) we have in the codebase as this used to cause double-frees:
byte[] serd = new byte[] {(byte)0xd9,(byte)0x77,(byte)0xcb,(byte)0x9b,(byte)0x53,(byte)0xd9,(byte)0x3a,(byte)0x6f,(byte)0xf6,(byte)0x4b,(byte)0xb5,(byte)0xf1,(byte)0xe1,(byte)0x58,(byte)0xb4,(byte)0x09,(byte)0x4b,(byte)0x66,(byte)0xe7,(byte)0x98,(byte)0xfb,(byte)0x12,(byte)0x91,(byte)0x11,(byte)0x68,(byte)0xa3,(byte)0xcc,(byte)0xdf,(byte)0x80,(byte)0xa8,(byte)0x30,(byte)0x96,(byte)0x34,(byte)0x0a,(byte)0x6a,(byte)0x95,(byte)0xda,(byte)0x0a,(byte)0xe8,(byte)0xd9,(byte)0xf7,(byte)0x76,(byte)0x52,(byte)0x8e,(byte)0xec,(byte)0xdb,(byte)0xb7,(byte)0x47,(byte)0xeb,(byte)0x6b,(byte)0x54,(byte)0x54,(byte)0x95,(byte)0xa4,(byte)0x31,(byte)0x9e,(byte)0xd5,(byte)0x37,(byte)0x8e,(byte)0x35,(byte)0xb2,(byte)0x1e,(byte)0x07,(byte)0x3a,(byte)0x00,(byte)0x00,(byte)0x00,(byte)0x00,(byte)0x00,(byte)0x19,(byte)0xd6,(byte)0x68,(byte)0x9c,(byte)0x08,(byte)0x5a,(byte)0xe1,(byte)0x65,(byte)0x83,(byte)0x1e,(byte)0x93,(byte)0x4f,(byte)0xf7,(byte)0x63,(byte)0xae,(byte)0x46,(byte)0xa2,(byte)0xa6,(byte)0xc1,(byte)0x72,(byte)0xb3,(byte)0xf1,(byte)0xb6,(byte)0x0a,(byte)0x8c,(byte)0xe2,(byte)0x6f,(byte)0x00,(byte)0x08,(byte)0x3a,(byte)0x84,(byte)0x00,(byte)0x00,(byte)0x03,(byte)0x4d,(byte)0x01,(byte)0x34,(byte)0x13,(byte)0xa7,(byte)0x00,(byte)0x00,(byte)0x00,(byte)0x90,(byte)0x00,(byte)0x00,(byte)0x00,(byte)0x00,(byte)0x00,(byte)0x0f,(byte)0x42,(byte)0x40,(byte)0x00,(byte)0x00,(byte)0x27,(byte)0x10,(byte)0x00,(byte)0x00,(byte)0x00,(byte)0x14,};
Result_ChannelUpdateDecodeErrorZ upd_msg = ChannelUpdate.read(serd);
import org.junit.jupiter.api.Test;
import org.ldk.impl.bindings;
import org.ldk.enums.*;
+import org.ldk.structs.Record;
public class ManualMsgHandlingPeerTest {
@Test
void test_message_handler() {
- long logger = bindings.LDKLogger_new((String arg)->{
- System.out.println(arg);
+ long logger = bindings.LDKLogger_new((long arg)->{
+ System.out.println(bindings.Record_get_args(arg));
+ bindings.Record_free(arg);
});
long chan_handler = bindings.LDKChannelMessageHandler_new(new bindings.LDKChannelMessageHandler() {
@Override
bindings.LDKBroadcasterInterface broad_trait;
bindings.LDKLogger log_trait;
bindings.LDKWatch watcher;
- ArrayList<Long> results_to_free;
Peer(byte seed) {
- this.log_trait = (String arg)-> System.out.println(seed + ": " + arg);
+ this.log_trait = (long arg) -> {
+ System.out.println(seed + ": " + bindings.Record_get_args(arg));
+ bindings.Record_free(arg);
+ };
logger = bindings.LDKLogger_new(this.log_trait);
this.fee_est = confirmation_target -> 0;
this.fee_estimator = bindings.LDKFeeEstimator_new(this.fee_est);
this.broad_trait = tx -> {
// We should broadcast
};
- this.results_to_free = new ArrayList<>();
this.tx_broadcaster = bindings.LDKBroadcasterInterface_new(this.broad_trait);
this.monitors = new HashMap<>();
this.watcher = new bindings.LDKWatch() {
assert monitors.put(Arrays.toString(bindings.OutPoint_get_txid(funding_txo)), monitor) == null;
}
bindings.OutPoint_free(funding_txo);
- long res = bindings.CResult_NoneChannelMonitorUpdateErrZ_ok();
- results_to_free.add(res);
- return res;
+ return bindings.CResult_NoneChannelMonitorUpdateErrZ_ok();
}
@Override
String txid = Arrays.toString(bindings.OutPoint_get_txid(funding_txo));
assert monitors.containsKey(txid);
long update_res = bindings.ChannelMonitor_update_monitor(monitors.get(txid), update, tx_broadcaster, fee_estimator, logger);
- assert bindings.LDKCResult_NoneMonitorUpdateErrorZ_result_ok(update_res);
+ assert bindings.CResult_NoneMonitorUpdateErrorZ_is_ok(update_res);
bindings.CResult_NoneMonitorUpdateErrorZ_free(update_res);
}
bindings.OutPoint_free(funding_txo);
bindings.ChannelMonitorUpdate_free(update);
- long res = bindings.CResult_NoneChannelMonitorUpdateErrZ_ok();
- results_to_free.add(res);
- return res;
+ return bindings.CResult_NoneChannelMonitorUpdateErrZ_ok();
}
@Override
bindings.ChannelMonitor_free(mon);
}
}
- for (Long res : results_to_free) {
- bindings.CResult_NoneChannelMonitorUpdateErrZ_free(res);
- }
}
}
void do_read_event(ConcurrentLinkedQueue<Thread> list, long pm, long descriptor, byte[] arr) {
Thread thread = new Thread(() -> {
long res = bindings.PeerManager_read_event(pm, descriptor, arr);
- assert bindings.LDKCResult_boolPeerHandleErrorZ_result_ok(res);
+ assert bindings.CResult_boolPeerHandleErrorZ_is_ok(res);
//assert bindings.deref_bool(bindings.LDKCResult_boolPeerHandleErrorZ_get_inner(res));
bindings.CResult_boolPeerHandleErrorZ_free(res);
});
descriptor1.val = bindings.LDKSocketDescriptor_new(sock2);
long init_vec = bindings.PeerManager_new_outbound_connection(peer1.peer_manager, peer2.node_id, descriptor1.val);
- assert(bindings.LDKCResult_CVec_u8ZPeerHandleErrorZ_result_ok(init_vec));
+ assert(bindings.CResult_CVec_u8ZPeerHandleErrorZ_is_ok(init_vec));
long con_res = bindings.PeerManager_new_inbound_connection(peer2.peer_manager, descriptor2);
- assert(bindings.LDKCResult_NonePeerHandleErrorZ_result_ok(con_res));
+ assert(bindings.CResult_NonePeerHandleErrorZ_is_ok(con_res));
bindings.CResult_NonePeerHandleErrorZ_free(con_res);
do_read_event(list, peer2.peer_manager, descriptor2, bindings.LDKCResult_CVec_u8ZPeerHandleErrorZ_get_ok(init_vec));
bindings.CResult_CVec_u8ZPeerHandleErrorZ_free(init_vec);
deliver_peer_messages(list, peer1.peer_manager, peer2.peer_manager);
long cc_res = bindings.ChannelManager_create_channel(peer1.chan_manager, peer2.node_id, 10000, 1000, 42, 0);
- assert bindings.LDKCResult_NoneAPIErrorZ_result_ok(cc_res);
+ assert bindings.CResult_NoneAPIErrorZ_is_ok(cc_res);
bindings.CResult_NoneAPIErrorZ_free(cc_res);
deliver_peer_messages(list, peer1.peer_manager, peer2.peer_manager);
bindings.Scorer_free(scorer);
for (long chan : peer1_chans) bindings.ChannelDetails_free(chan);
- assert bindings.LDKCResult_RouteLightningErrorZ_result_ok(route);
+ assert bindings.CResult_RouteLightningErrorZ_is_ok(route);
long payment_res = bindings.ChannelManager_send_payment(peer1.chan_manager, bindings.LDKCResult_RouteLightningErrorZ_get_ok(route),
bindings.C2Tuple_PaymentHashPaymentSecretZ_get_a(inbound_payment), bindings.C2Tuple_PaymentHashPaymentSecretZ_get_b(inbound_payment));
bindings.CResult_RouteLightningErrorZ_free(route);
bindings.C2Tuple_PaymentHashPaymentSecretZ_free(inbound_payment);
- assert bindings.LDKCResult_NonePaymentSendFailureZ_result_ok(payment_res);
+ assert bindings.CResult_NonePaymentSendFailureZ_is_ok(payment_res);
bindings.CResult_NonePaymentSendFailureZ_free(payment_res);
deliver_peer_messages(list, peer1.peer_manager, peer2.peer_manager);
#define DO_ASSERT(a) (void)(a)
#define CHECK(a)
#define CHECK_ACCESS(p)
+#define CHECK_INNER_FIELD_ACCESS_OR_NULL(v)
// We assume that CVec_u8Z and u8slice are the same size and layout (and thus pointers to the two can be mixed)
_Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKu8slice), "Vec<u8> and [u8] need to have been mapped identically");
default: abort();
}
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_u8Z_new(int8_tArray elems) {
- LDKCVec_u8Z *ret = MALLOC(sizeof(LDKCVec_u8Z), "LDKCVec_u8Z");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(uint8_t) * ret->datalen, "LDKCVec_u8Z Data");
- int8_t *java_elems = (int8_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- ret->data[i] = java_elems[i];
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_u8Z CVec_u8Z_clone(const LDKCVec_u8Z *orig) {
LDKCVec_u8Z ret = { .data = MALLOC(sizeof(int8_t) * orig->datalen, "LDKCVec_u8Z clone bytes"), .datalen = orig->datalen };
memcpy(ret.data, orig->data, sizeof(int8_t) * ret.datalen);
return ret_val;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_SecretKeyErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_SecretKeyErrorZ*)arg)->result_ok;
-}
int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_SecretKeyErrorZ_get_ok(uint32_t arg) {
LDKCResult_SecretKeyErrorZ *val = (LDKCResult_SecretKeyErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint32_t err_conv = LDKSecp256k1Error_to_js((*val->contents.err));
return err_conv;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_PublicKeyErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_PublicKeyErrorZ*)arg)->result_ok;
-}
int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_PublicKeyErrorZ_get_ok(uint32_t arg) {
LDKCResult_PublicKeyErrorZ *val = (LDKCResult_PublicKeyErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint32_t err_conv = LDKSecp256k1Error_to_js((*val->contents.err));
return err_conv;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_TxCreationKeysDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_TxCreationKeysDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_TxCreationKeysDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_TxCreationKeysDecodeErrorZ *val = (LDKCResult_TxCreationKeysDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelPublicKeysDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ChannelPublicKeysDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelPublicKeysDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ChannelPublicKeysDecodeErrorZ *val = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_TxCreationKeysErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_TxCreationKeysErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_TxCreationKeysErrorZ_get_ok(uint32_t arg) {
LDKCResult_TxCreationKeysErrorZ *val = (LDKCResult_TxCreationKeysErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
default: abort();
}
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *val = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *val = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelTransactionParametersDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ChannelTransactionParametersDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelTransactionParametersDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ChannelTransactionParametersDecodeErrorZ *val = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_HolderCommitmentTransactionDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_HolderCommitmentTransactionDecodeErrorZ *val = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_BuiltCommitmentTransactionDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *val = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_TrustedClosingTransactionNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_TrustedClosingTransactionNoneZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_TrustedClosingTransactionNoneZ_get_ok(uint32_t arg) {
LDKCResult_TrustedClosingTransactionNoneZ *val = (LDKCResult_TrustedClosingTransactionNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
CHECK(!val->result_ok);
return *val->contents.err;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_CommitmentTransactionDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_CommitmentTransactionDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_CommitmentTransactionDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_CommitmentTransactionDecodeErrorZ *val = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_TrustedCommitmentTransactionNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_TrustedCommitmentTransactionNoneZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_TrustedCommitmentTransactionNoneZ_get_ok(uint32_t arg) {
LDKCResult_TrustedCommitmentTransactionNoneZ *val = (LDKCResult_TrustedCommitmentTransactionNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
CHECK(!val->result_ok);
return *val->contents.err;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_CVec_SignatureZNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_CVec_SignatureZNoneZ*)arg)->result_ok;
-}
ptrArray __attribute__((visibility("default"))) TS_LDKCResult_CVec_SignatureZNoneZ_get_ok(uint32_t arg) {
LDKCResult_CVec_SignatureZNoneZ *val = (LDKCResult_CVec_SignatureZNoneZ*)(arg & ~1);
CHECK(val->result_ok);
CHECK(!val->result_ok);
return *val->contents.err;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ShutdownScriptDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ShutdownScriptDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ShutdownScriptDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ShutdownScriptDecodeErrorZ *val = (LDKCResult_ShutdownScriptDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ShutdownScriptInvalidShutdownScriptZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(uint32_t arg) {
LDKCResult_ShutdownScriptInvalidShutdownScriptZ *val = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NoneErrorZ*)arg)->result_ok;
-}
void __attribute__((visibility("default"))) TS_LDKCResult_NoneErrorZ_get_ok(uint32_t arg) {
LDKCResult_NoneErrorZ *val = (LDKCResult_NoneErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint32_t err_conv = LDKIOError_to_js((*val->contents.err));
return err_conv;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_RouteHopDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_RouteHopDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RouteHopDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_RouteHopDecodeErrorZ *val = (LDKCResult_RouteHopDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_RouteHopZ_new(uint32_tArray elems) {
- LDKCVec_RouteHopZ *ret = MALLOC(sizeof(LDKCVec_RouteHopZ), "LDKCVec_RouteHopZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKRouteHop) * ret->datalen, "LDKCVec_RouteHopZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKRouteHop arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = RouteHop_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_RouteHopZ CVec_RouteHopZ_clone(const LDKCVec_RouteHopZ *orig) {
LDKCVec_RouteHopZ ret = { .data = MALLOC(sizeof(LDKRouteHop) * orig->datalen, "LDKCVec_RouteHopZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_RouteDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_RouteDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RouteDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_RouteDecodeErrorZ *val = (LDKCResult_RouteDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_RouteParametersDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_RouteParametersDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RouteParametersDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_RouteParametersDecodeErrorZ *val = (LDKCResult_RouteParametersDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_RouteHintZ_new(uint32_tArray elems) {
- LDKCVec_RouteHintZ *ret = MALLOC(sizeof(LDKCVec_RouteHintZ), "LDKCVec_RouteHintZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKRouteHint) * ret->datalen, "LDKCVec_RouteHintZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKRouteHint arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = RouteHint_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_RouteHintZ CVec_RouteHintZ_clone(const LDKCVec_RouteHintZ *orig) {
LDKCVec_RouteHintZ ret = { .data = MALLOC(sizeof(LDKRouteHint) * orig->datalen, "LDKCVec_RouteHintZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
default: abort();
}
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_PayeeDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_PayeeDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PayeeDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_PayeeDecodeErrorZ *val = (LDKCResult_PayeeDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_RouteHintHopZ_new(uint32_tArray elems) {
- LDKCVec_RouteHintHopZ *ret = MALLOC(sizeof(LDKCVec_RouteHintHopZ), "LDKCVec_RouteHintHopZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKRouteHintHop) * ret->datalen, "LDKCVec_RouteHintHopZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKRouteHintHop arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = RouteHintHop_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_RouteHintHopZ CVec_RouteHintHopZ_clone(const LDKCVec_RouteHintHopZ *orig) {
LDKCVec_RouteHintHopZ ret = { .data = MALLOC(sizeof(LDKRouteHintHop) * orig->datalen, "LDKCVec_RouteHintHopZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_RouteHintDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_RouteHintDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RouteHintDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_RouteHintDecodeErrorZ *val = (LDKCResult_RouteHintDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_RouteHintHopDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_RouteHintHopDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RouteHintHopDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_RouteHintHopDecodeErrorZ *val = (LDKCResult_RouteHintHopDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_ChannelDetailsZ_new(uint32_tArray elems) {
- LDKCVec_ChannelDetailsZ *ret = MALLOC(sizeof(LDKCVec_ChannelDetailsZ), "LDKCVec_ChannelDetailsZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKChannelDetails) * ret->datalen, "LDKCVec_ChannelDetailsZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKChannelDetails arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = ChannelDetails_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_ChannelDetailsZ CVec_ChannelDetailsZ_clone(const LDKCVec_ChannelDetailsZ *orig) {
LDKCVec_ChannelDetailsZ ret = { .data = MALLOC(sizeof(LDKChannelDetails) * orig->datalen, "LDKCVec_ChannelDetailsZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_RouteLightningErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_RouteLightningErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RouteLightningErrorZ_get_ok(uint32_t arg) {
LDKCResult_RouteLightningErrorZ *val = (LDKCResult_RouteLightningErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_TxOutAccessErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_TxOutAccessErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_TxOutAccessErrorZ_get_ok(uint32_t arg) {
LDKCResult_TxOutAccessErrorZ *val = (LDKCResult_TxOutAccessErrorZ*)(arg & ~1);
CHECK(val->result_ok);
return ret_arr;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_usizeTransactionZZ_new(uint32_tArray elems) {
- LDKCVec_C2Tuple_usizeTransactionZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_usizeTransactionZZ), "LDKCVec_C2Tuple_usizeTransactionZZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ) * ret->datalen, "LDKCVec_C2Tuple_usizeTransactionZZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_usizeTransactionZ arr_elem_conv = *(LDKC2Tuple_usizeTransactionZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_usizeTransactionZZ CVec_C2Tuple_usizeTransactionZZ_clone(const LDKCVec_C2Tuple_usizeTransactionZZ *orig) {
LDKCVec_C2Tuple_usizeTransactionZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ) * orig->datalen, "LDKCVec_C2Tuple_usizeTransactionZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneChannelMonitorUpdateErrZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NoneChannelMonitorUpdateErrZ*)arg)->result_ok;
-}
void __attribute__((visibility("default"))) TS_LDKCResult_NoneChannelMonitorUpdateErrZ_get_ok(uint32_t arg) {
LDKCResult_NoneChannelMonitorUpdateErrZ *val = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t htlc_event_ref = 0;
CHECK((((uint64_t)htlc_event_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&htlc_event_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_event_var);
htlc_event_ref = (uint64_t)htlc_event_var.inner & ~1;
return 0 /* LDKMonitorEvent - HTLCEvent */; (void) htlc_event_ref;
}
uint64_t commitment_tx_confirmed_ref = 0;
CHECK((((uint64_t)commitment_tx_confirmed_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&commitment_tx_confirmed_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_confirmed_var);
commitment_tx_confirmed_ref = (uint64_t)commitment_tx_confirmed_var.inner & ~1;
return 0 /* LDKMonitorEvent - CommitmentTxConfirmed */; (void) commitment_tx_confirmed_ref;
}
uint64_t funding_txo_ref = 0;
CHECK((((uint64_t)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
funding_txo_ref = (uint64_t)funding_txo_var.inner & ~1;
return 0 /* LDKMonitorEvent - UpdateCompleted */; (void) funding_txo_ref; (void) obj->update_completed.monitor_update_id;
}
uint64_t update_failed_ref = 0;
CHECK((((uint64_t)update_failed_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_failed_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_failed_var);
update_failed_ref = (uint64_t)update_failed_var.inner & ~1;
return 0 /* LDKMonitorEvent - UpdateFailed */; (void) update_failed_ref;
}
default: abort();
}
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_MonitorEventZ_new(uint32_tArray elems) {
- LDKCVec_MonitorEventZ *ret = MALLOC(sizeof(LDKCVec_MonitorEventZ), "LDKCVec_MonitorEventZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKMonitorEvent) * ret->datalen, "LDKCVec_MonitorEventZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKMonitorEvent arr_elem_conv = *(LDKMonitorEvent*)(arr_elem_ptr);
- arr_elem_conv = MonitorEvent_clone((LDKMonitorEvent*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_MonitorEventZ CVec_MonitorEventZ_clone(const LDKCVec_MonitorEventZ *orig) {
LDKCVec_MonitorEventZ ret = { .data = MALLOC(sizeof(LDKMonitorEvent) * orig->datalen, "LDKCVec_MonitorEventZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
default: abort();
}
}
+uint32_t __attribute__((visibility("default"))) TS_LDKClosureReason_ref_from_ptr(uint32_t ptr) {
+ LDKClosureReason *obj = (LDKClosureReason*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKClosureReason_CounterpartyForceClosed: {
+ LDKStr peer_msg_str = obj->counterparty_force_closed.peer_msg;
+ jstring peer_msg_conv = str_ref_to_ts(peer_msg_str.chars, peer_msg_str.len);
+ return 0 /* LDKClosureReason - CounterpartyForceClosed */; (void) peer_msg_conv;
+ }
+ case LDKClosureReason_HolderForceClosed: {
+ return 0 /* LDKClosureReason - HolderForceClosed */;
+ }
+ case LDKClosureReason_CooperativeClosure: {
+ return 0 /* LDKClosureReason - CooperativeClosure */;
+ }
+ case LDKClosureReason_CommitmentTxConfirmed: {
+ return 0 /* LDKClosureReason - CommitmentTxConfirmed */;
+ }
+ case LDKClosureReason_ProcessingError: {
+ LDKStr err_str = obj->processing_error.err;
+ jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
+ return 0 /* LDKClosureReason - ProcessingError */; (void) err_conv;
+ }
+ case LDKClosureReason_DisconnectedPeer: {
+ return 0 /* LDKClosureReason - DisconnectedPeer */;
+ }
+ case LDKClosureReason_OutdatedChannelManager: {
+ return 0 /* LDKClosureReason - OutdatedChannelManager */;
+ }
+ default: abort();
+ }
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCOption_ClosureReasonZ_ref_from_ptr(uint32_t ptr) {
+ LDKCOption_ClosureReasonZ *obj = (LDKCOption_ClosureReasonZ*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKCOption_ClosureReasonZ_Some: {
+ uint64_t some_ref = ((uint64_t)&obj->some) | 1;
+ return 0 /* LDKCOption_ClosureReasonZ - Some */; (void) some_ref;
+ }
+ case LDKCOption_ClosureReasonZ_None: {
+ return 0 /* LDKCOption_ClosureReasonZ - None */;
+ }
+ default: abort();
+ }
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCResult_COption_ClosureReasonZDecodeErrorZ_get_ok(uint32_t arg) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ *val = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(arg & ~1);
+ CHECK(val->result_ok);
+ uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
+ return res_ref;
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCResult_COption_ClosureReasonZDecodeErrorZ_get_err(uint32_t arg) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ *val = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(arg & ~1);
+ CHECK(!val->result_ok);
+ LDKDecodeError err_var = (*val->contents.err);
+ uint64_t err_ref = 0;
+ CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
+ err_ref = (uint64_t)err_var.inner & ~1;
+ return err_ref;
+}
uint32_t __attribute__((visibility("default"))) TS_LDKNetworkUpdate_ref_from_ptr(uint32_t ptr) {
LDKNetworkUpdate *obj = (LDKNetworkUpdate*)(ptr & ~1);
switch(obj->tag) {
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKNetworkUpdate - ChannelUpdateMessage */; (void) msg_ref;
}
uint64_t outpoint_ref = 0;
CHECK((((uint64_t)outpoint_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&outpoint_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_var);
outpoint_ref = (uint64_t)outpoint_var.inner & ~1;
uint64_t output_ref = ((uint64_t)&obj->static_output.output) | 1;
return 0 /* LDKSpendableOutputDescriptor - StaticOutput */; (void) outpoint_ref; (void) (uint64_t)output_ref;
uint64_t delayed_payment_output_ref = 0;
CHECK((((uint64_t)delayed_payment_output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&delayed_payment_output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(delayed_payment_output_var);
delayed_payment_output_ref = (uint64_t)delayed_payment_output_var.inner & ~1;
return 0 /* LDKSpendableOutputDescriptor - DelayedPaymentOutput */; (void) delayed_payment_output_ref;
}
uint64_t static_payment_output_ref = 0;
CHECK((((uint64_t)static_payment_output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&static_payment_output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(static_payment_output_var);
static_payment_output_ref = (uint64_t)static_payment_output_var.inner & ~1;
return 0 /* LDKSpendableOutputDescriptor - StaticPaymentOutput */; (void) static_payment_output_ref;
}
default: abort();
}
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_SpendableOutputDescriptorZ_new(uint32_tArray elems) {
- LDKCVec_SpendableOutputDescriptorZ *ret = MALLOC(sizeof(LDKCVec_SpendableOutputDescriptorZ), "LDKCVec_SpendableOutputDescriptorZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKSpendableOutputDescriptor) * ret->datalen, "LDKCVec_SpendableOutputDescriptorZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKSpendableOutputDescriptor arr_elem_conv = *(LDKSpendableOutputDescriptor*)(arr_elem_ptr);
- arr_elem_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_SpendableOutputDescriptorZ CVec_SpendableOutputDescriptorZ_clone(const LDKCVec_SpendableOutputDescriptorZ *orig) {
LDKCVec_SpendableOutputDescriptorZ ret = { .data = MALLOC(sizeof(LDKSpendableOutputDescriptor) * orig->datalen, "LDKCVec_SpendableOutputDescriptorZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
+uint32_t __attribute__((visibility("default"))) TS_LDKPaymentPurpose_ref_from_ptr(uint32_t ptr) {
+ LDKPaymentPurpose *obj = (LDKPaymentPurpose*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKPaymentPurpose_InvoicePayment: {
+ int8_tArray payment_preimage_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(payment_preimage_arr + 4), obj->invoice_payment.payment_preimage.data, 32);
+ int8_tArray payment_secret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(payment_secret_arr + 4), obj->invoice_payment.payment_secret.data, 32);
+ return 0 /* LDKPaymentPurpose - InvoicePayment */; (void) payment_preimage_arr; (void) payment_secret_arr; (void) obj->invoice_payment.user_payment_id;
+ }
+ case LDKPaymentPurpose_SpontaneousPayment: {
+ int8_tArray spontaneous_payment_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(spontaneous_payment_arr + 4), obj->spontaneous_payment.data, 32);
+ return 0 /* LDKPaymentPurpose - SpontaneousPayment */; (void) spontaneous_payment_arr;
+ }
+ default: abort();
+ }
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKEvent_ref_from_ptr(uint32_t ptr) {
+ LDKEvent *obj = (LDKEvent*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKEvent_FundingGenerationReady: {
+ int8_tArray temporary_channel_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(temporary_channel_id_arr + 4), obj->funding_generation_ready.temporary_channel_id.data, 32);
+ LDKCVec_u8Z output_script_var = obj->funding_generation_ready.output_script;
+ int8_tArray output_script_arr = init_arr(output_script_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(output_script_arr + 4), output_script_var.data, output_script_var.datalen);
+ return 0 /* LDKEvent - FundingGenerationReady */; (void) temporary_channel_id_arr; (void) obj->funding_generation_ready.channel_value_satoshis; (void) output_script_arr; (void) obj->funding_generation_ready.user_channel_id;
+ }
+ case LDKEvent_PaymentReceived: {
+ int8_tArray payment_hash_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(payment_hash_arr + 4), obj->payment_received.payment_hash.data, 32);
+ uint64_t purpose_ref = ((uint64_t)&obj->payment_received.purpose) | 1;
+ return 0 /* LDKEvent - PaymentReceived */; (void) payment_hash_arr; (void) obj->payment_received.amt; (void) purpose_ref;
+ }
+ case LDKEvent_PaymentSent: {
+ int8_tArray payment_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(payment_id_arr + 4), obj->payment_sent.payment_id.data, 32);
+ int8_tArray payment_preimage_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(payment_preimage_arr + 4), obj->payment_sent.payment_preimage.data, 32);
+ int8_tArray payment_hash_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(payment_hash_arr + 4), obj->payment_sent.payment_hash.data, 32);
+ uint64_t fee_paid_msat_ref = ((uint64_t)&obj->payment_sent.fee_paid_msat) | 1;
+ return 0 /* LDKEvent - PaymentSent */; (void) payment_id_arr; (void) payment_preimage_arr; (void) payment_hash_arr; (void) fee_paid_msat_ref;
+ }
+ case LDKEvent_PaymentPathFailed: {
+ int8_tArray payment_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(payment_id_arr + 4), obj->payment_path_failed.payment_id.data, 32);
+ int8_tArray payment_hash_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(payment_hash_arr + 4), obj->payment_path_failed.payment_hash.data, 32);
+ uint64_t network_update_ref = ((uint64_t)&obj->payment_path_failed.network_update) | 1;
+ LDKCVec_RouteHopZ path_var = obj->payment_path_failed.path;
+ uint32_tArray path_arr = NULL;
+ path_arr = init_arr(path_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
+ uint32_t *path_arr_ptr = (uint32_t*)(path_arr + 4);
+ for (size_t k = 0; k < path_var.datalen; k++) {
+ LDKRouteHop path_conv_10_var = path_var.data[k];
+ uint64_t path_conv_10_ref = 0;
+ CHECK((((uint64_t)path_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&path_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
+ path_conv_10_ref = (uint64_t)path_conv_10_var.inner & ~1;
+ path_arr_ptr[k] = path_conv_10_ref;
+ }
+
+ uint64_t short_channel_id_ref = ((uint64_t)&obj->payment_path_failed.short_channel_id) | 1;
+ LDKRouteParameters retry_var = obj->payment_path_failed.retry;
+ uint64_t retry_ref = 0;
+ if ((uint64_t)retry_var.inner > 4096) {
+ CHECK((((uint64_t)retry_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&retry_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(retry_var);
+ retry_ref = (uint64_t)retry_var.inner & ~1;
+ }
+ return 0 /* LDKEvent - PaymentPathFailed */; (void) payment_id_arr; (void) payment_hash_arr; (void) obj->payment_path_failed.rejected_by_dest; (void) network_update_ref; (void) obj->payment_path_failed.all_paths_failed; (void) path_arr; (void) short_channel_id_ref; (void) retry_ref;
+ }
+ case LDKEvent_PendingHTLCsForwardable: {
+ return 0 /* LDKEvent - PendingHTLCsForwardable */; (void) obj->pending_htl_cs_forwardable.time_forwardable;
+ }
+ case LDKEvent_SpendableOutputs: {
+ LDKCVec_SpendableOutputDescriptorZ outputs_var = obj->spendable_outputs.outputs;
+ uint32_tArray outputs_arr = NULL;
+ outputs_arr = init_arr(outputs_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
+ uint32_t *outputs_arr_ptr = (uint32_t*)(outputs_arr + 4);
+ for (size_t b = 0; b < outputs_var.datalen; b++) {
+ uint64_t outputs_conv_27_ref = ((uint64_t)&outputs_var.data[b]) | 1;
+ outputs_arr_ptr[b] = outputs_conv_27_ref;
+ }
+
+ return 0 /* LDKEvent - SpendableOutputs */; (void) outputs_arr;
+ }
+ case LDKEvent_PaymentForwarded: {
+ uint64_t fee_earned_msat_ref = ((uint64_t)&obj->payment_forwarded.fee_earned_msat) | 1;
+ return 0 /* LDKEvent - PaymentForwarded */; (void) fee_earned_msat_ref; (void) obj->payment_forwarded.claim_from_onchain_tx;
+ }
+ case LDKEvent_ChannelClosed: {
+ int8_tArray channel_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(channel_id_arr + 4), obj->channel_closed.channel_id.data, 32);
+ uint64_t reason_ref = ((uint64_t)&obj->channel_closed.reason) | 1;
+ return 0 /* LDKEvent - ChannelClosed */; (void) channel_id_arr; (void) obj->channel_closed.user_channel_id; (void) reason_ref;
+ }
+ case LDKEvent_DiscardFunding: {
+ int8_tArray channel_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(channel_id_arr + 4), obj->discard_funding.channel_id.data, 32);
+ LDKTransaction transaction_var = obj->discard_funding.transaction;
+ int8_tArray transaction_arr = init_arr(transaction_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(transaction_arr + 4), transaction_var.data, transaction_var.datalen);
+ return 0 /* LDKEvent - DiscardFunding */; (void) channel_id_arr; (void) transaction_arr;
+ }
+ default: abort();
+ }
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCOption_EventZ_ref_from_ptr(uint32_t ptr) {
+ LDKCOption_EventZ *obj = (LDKCOption_EventZ*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKCOption_EventZ_Some: {
+ uint64_t some_ref = ((uint64_t)&obj->some) | 1;
+ return 0 /* LDKCOption_EventZ - Some */; (void) some_ref;
+ }
+ case LDKCOption_EventZ_None: {
+ return 0 /* LDKCOption_EventZ - None */;
+ }
+ default: abort();
+ }
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCResult_COption_EventZDecodeErrorZ_get_ok(uint32_t arg) {
+ LDKCResult_COption_EventZDecodeErrorZ *val = (LDKCResult_COption_EventZDecodeErrorZ*)(arg & ~1);
+ CHECK(val->result_ok);
+ uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
+ return res_ref;
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCResult_COption_EventZDecodeErrorZ_get_err(uint32_t arg) {
+ LDKCResult_COption_EventZDecodeErrorZ *val = (LDKCResult_COption_EventZDecodeErrorZ*)(arg & ~1);
+ CHECK(!val->result_ok);
+ LDKDecodeError err_var = (*val->contents.err);
+ uint64_t err_ref = 0;
+ CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
+ err_ref = (uint64_t)err_var.inner & ~1;
+ return err_ref;
+}
uint32_t __attribute__((visibility("default"))) TS_LDKErrorAction_ref_from_ptr(uint32_t ptr) {
LDKErrorAction *obj = (LDKErrorAction*)(ptr & ~1);
switch(obj->tag) {
if ((uint64_t)msg_var.inner > 4096) {
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
}
return 0 /* LDKErrorAction - DisconnectPeer */; (void) msg_ref;
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKErrorAction - SendErrorMessage */; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendAcceptChannel */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendOpenChannel */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendFundingCreated */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendFundingSigned */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendFundingLocked */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendAnnouncementSignatures */; (void) node_id_arr; (void) msg_ref;
}
uint64_t updates_ref = 0;
CHECK((((uint64_t)updates_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&updates_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_var);
updates_ref = (uint64_t)updates_var.inner & ~1;
return 0 /* LDKMessageSendEvent - UpdateHTLCs */; (void) node_id_arr; (void) updates_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendRevokeAndACK */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendClosingSigned */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendShutdown */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendChannelReestablish */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
LDKChannelUpdate update_msg_var = obj->broadcast_channel_announcement.update_msg;
uint64_t update_msg_ref = 0;
CHECK((((uint64_t)update_msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_var);
update_msg_ref = (uint64_t)update_msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - BroadcastChannelAnnouncement */; (void) msg_ref; (void) update_msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - BroadcastNodeAnnouncement */; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - BroadcastChannelUpdate */; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendChannelUpdate */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendChannelRangeQuery */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendShortIdsQuery */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendReplyChannelRange */; (void) node_id_arr; (void) msg_ref;
}
default: abort();
}
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_MessageSendEventZ_new(uint32_tArray elems) {
- LDKCVec_MessageSendEventZ *ret = MALLOC(sizeof(LDKCVec_MessageSendEventZ), "LDKCVec_MessageSendEventZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKMessageSendEvent) * ret->datalen, "LDKCVec_MessageSendEventZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKMessageSendEvent arr_elem_conv = *(LDKMessageSendEvent*)(arr_elem_ptr);
- arr_elem_conv = MessageSendEvent_clone((LDKMessageSendEvent*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_MessageSendEventZ CVec_MessageSendEventZ_clone(const LDKCVec_MessageSendEventZ *orig) {
LDKCVec_MessageSendEventZ ret = { .data = MALLOC(sizeof(LDKMessageSendEvent) * orig->datalen, "LDKCVec_MessageSendEventZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_InitFeaturesDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_InitFeaturesDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InitFeaturesDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_InitFeaturesDecodeErrorZ *val = (LDKCResult_InitFeaturesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NodeFeaturesDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NodeFeaturesDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NodeFeaturesDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_NodeFeaturesDecodeErrorZ *val = (LDKCResult_NodeFeaturesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelFeaturesDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ChannelFeaturesDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelFeaturesDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ChannelFeaturesDecodeErrorZ *val = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_InvoiceFeaturesDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_InvoiceFeaturesDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InvoiceFeaturesDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_InvoiceFeaturesDecodeErrorZ *val = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ScoringParametersDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ScoringParametersDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ScoringParametersDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ScoringParametersDecodeErrorZ *val = (LDKCResult_ScoringParametersDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ScorerDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ScorerDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ScorerDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ScorerDecodeErrorZ *val = (LDKCResult_ScorerDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *val = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *val = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_SpendableOutputDescriptorDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_SpendableOutputDescriptorDecodeErrorZ *val = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NoneNoneZ*)arg)->result_ok;
-}
void __attribute__((visibility("default"))) TS_LDKCResult_NoneNoneZ_get_ok(uint32_t arg) {
LDKCResult_NoneNoneZ *val = (LDKCResult_NoneNoneZ*)(arg & ~1);
CHECK(val->result_ok);
return ret_arr;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(uint32_t arg) {
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *val = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(arg & ~1);
CHECK(val->result_ok);
CHECK(!val->result_ok);
return *val->contents.err;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_SignatureNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_SignatureNoneZ*)arg)->result_ok;
-}
int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_SignatureNoneZ_get_ok(uint32_t arg) {
LDKCResult_SignatureNoneZ *val = (LDKCResult_SignatureNoneZ*)(arg & ~1);
CHECK(val->result_ok);
holder_tx_var = HolderCommitmentTransaction_clone(holder_tx);
CHECK((((uint64_t)holder_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&holder_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_tx_var);
holder_tx_ref = (uint64_t)holder_tx_var.inner;
if (holder_tx_var.is_owned) {
holder_tx_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
- ret_conv = CResult_NoneNoneZ_clone((LDKCResult_NoneNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKThirtyTwoBytes channel_keys_id_LDKBaseSign_jcall(const void* this_arg) {
commitment_tx_var = CommitmentTransaction_clone(commitment_tx);
CHECK((((uint64_t)commitment_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&commitment_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_var);
commitment_tx_ref = (uint64_t)commitment_tx_var.inner;
if (commitment_tx_var.is_owned) {
commitment_tx_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(ret_ptr);
- ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_NoneNoneZ validate_counterparty_revocation_LDKBaseSign_jcall(const void* this_arg, uint64_t idx, const uint8_t (* secret)[32]) {
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
- ret_conv = CResult_NoneNoneZ_clone((LDKCResult_NoneNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_holder_commitment_and_htlcs_LDKBaseSign_jcall(const void* this_arg, const LDKHolderCommitmentTransaction * commitment_tx) {
commitment_tx_var = HolderCommitmentTransaction_clone(commitment_tx);
CHECK((((uint64_t)commitment_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&commitment_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_var);
commitment_tx_ref = (uint64_t)commitment_tx_var.inner;
if (commitment_tx_var.is_owned) {
commitment_tx_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(ret_ptr);
- ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_SignatureNoneZ sign_justice_revoked_output_LDKBaseSign_jcall(const void* this_arg, LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (* per_commitment_key)[32]) {
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_SignatureNoneZ sign_justice_revoked_htlc_LDKBaseSign_jcall(const void* this_arg, LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (* per_commitment_key)[32], const LDKHTLCOutputInCommitment * htlc) {
htlc_var = HTLCOutputInCommitment_clone(htlc);
CHECK((((uint64_t)htlc_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&htlc_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_var);
htlc_ref = (uint64_t)htlc_var.inner;
if (htlc_var.is_owned) {
htlc_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_SignatureNoneZ sign_counterparty_htlc_transaction_LDKBaseSign_jcall(const void* this_arg, LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, LDKPublicKey per_commitment_point, const LDKHTLCOutputInCommitment * htlc) {
htlc_var = HTLCOutputInCommitment_clone(htlc);
CHECK((((uint64_t)htlc_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&htlc_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_var);
htlc_ref = (uint64_t)htlc_var.inner;
if (htlc_var.is_owned) {
htlc_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_SignatureNoneZ sign_closing_transaction_LDKBaseSign_jcall(const void* this_arg, const LDKClosingTransaction * closing_tx) {
closing_tx_var = ClosingTransaction_clone(closing_tx);
CHECK((((uint64_t)closing_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&closing_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(closing_tx_var);
closing_tx_ref = (uint64_t)closing_tx_var.inner;
if (closing_tx_var.is_owned) {
closing_tx_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_SignatureNoneZ sign_channel_announcement_LDKBaseSign_jcall(const void* this_arg, const LDKUnsignedChannelAnnouncement * msg) {
msg_var = UnsignedChannelAnnouncement_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
void ready_channel_LDKBaseSign_jcall(void* this_arg, const LDKChannelTransactionParameters * channel_parameters) {
channel_parameters_var = ChannelTransactionParameters_clone(channel_parameters);
CHECK((((uint64_t)channel_parameters_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&channel_parameters_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_var);
channel_parameters_ref = (uint64_t)channel_parameters_var.inner;
if (channel_parameters_var.is_owned) {
channel_parameters_ref |= 1;
LDKChannelPublicKeys pubkeys_conv;
pubkeys_conv.inner = (void*)(pubkeys & (~1));
pubkeys_conv.is_owned = (pubkeys & 1) || (pubkeys == 0);
- pubkeys_conv = ChannelPublicKeys_clone(&pubkeys_conv);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_conv);
LDKBaseSign ret = {
.this_arg = (void*) calls,
LDKHolderCommitmentTransaction holder_tx_conv;
holder_tx_conv.inner = (void*)(holder_tx & (~1));
holder_tx_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_tx_conv);
LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
*ret_conv = (this_arg_conv->validate_holder_commitment)(this_arg_conv->this_arg, &holder_tx_conv);
return (uint64_t)ret_conv;
LDKCommitmentTransaction commitment_tx_conv;
commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
commitment_tx_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
*ret_conv = (this_arg_conv->sign_counterparty_commitment)(this_arg_conv->this_arg, &commitment_tx_conv);
return (uint64_t)ret_conv;
LDKHolderCommitmentTransaction commitment_tx_conv;
commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
commitment_tx_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
*ret_conv = (this_arg_conv->sign_holder_commitment_and_htlcs)(this_arg_conv->this_arg, &commitment_tx_conv);
return (uint64_t)ret_conv;
LDKHTLCOutputInCommitment htlc_conv;
htlc_conv.inner = (void*)(htlc & (~1));
htlc_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
*ret_conv = (this_arg_conv->sign_justice_revoked_htlc)(this_arg_conv->this_arg, justice_tx_ref, input, amount, per_commitment_key_ref, &htlc_conv);
return (uint64_t)ret_conv;
LDKHTLCOutputInCommitment htlc_conv;
htlc_conv.inner = (void*)(htlc & (~1));
htlc_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
*ret_conv = (this_arg_conv->sign_counterparty_htlc_transaction)(this_arg_conv->this_arg, htlc_tx_ref, input, amount, per_commitment_point_ref, &htlc_conv);
return (uint64_t)ret_conv;
LDKClosingTransaction closing_tx_conv;
closing_tx_conv.inner = (void*)(closing_tx & (~1));
closing_tx_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(closing_tx_conv);
LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
*ret_conv = (this_arg_conv->sign_closing_transaction)(this_arg_conv->this_arg, &closing_tx_conv);
return (uint64_t)ret_conv;
LDKUnsignedChannelAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
*ret_conv = (this_arg_conv->sign_channel_announcement)(this_arg_conv->this_arg, &msg_conv);
return (uint64_t)ret_conv;
LDKChannelTransactionParameters channel_parameters_conv;
channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
channel_parameters_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
(this_arg_conv->ready_channel)(this_arg_conv->this_arg, &channel_parameters_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelPublicKeys pubkeys_conv;
pubkeys_conv.inner = (void*)(pubkeys & (~1));
pubkeys_conv.is_owned = (pubkeys & 1) || (pubkeys == 0);
- pubkeys_conv = ChannelPublicKeys_clone(&pubkeys_conv);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_conv);
LDKSign ret = {
.this_arg = (void*) calls,
return ret_arr;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_SignDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_SignDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_SignDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_SignDecodeErrorZ *val = (LDKCResult_SignDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_RecoverableSignatureNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_RecoverableSignatureNoneZ*)arg)->result_ok;
-}
int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_RecoverableSignatureNoneZ_get_ok(uint32_t arg) {
LDKCResult_RecoverableSignatureNoneZ *val = (LDKCResult_RecoverableSignatureNoneZ*)(arg & ~1);
CHECK(val->result_ok);
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_CVec_CVec_u8ZZNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_CVec_CVec_u8ZZNoneZ*)arg)->result_ok;
-}
ptrArray __attribute__((visibility("default"))) TS_LDKCResult_CVec_CVec_u8ZZNoneZ_get_ok(uint32_t arg) {
LDKCResult_CVec_CVec_u8ZZNoneZ *val = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(arg & ~1);
CHECK(val->result_ok);
CHECK(!val->result_ok);
return *val->contents.err;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_InMemorySignerDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_InMemorySignerDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InMemorySignerDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_InMemorySignerDecodeErrorZ *val = (LDKCResult_InMemorySignerDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_TxOutZ_new(uint32_tArray elems) {
- LDKCVec_TxOutZ *ret = MALLOC(sizeof(LDKCVec_TxOutZ), "LDKCVec_TxOutZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKTxOut) * ret->datalen, "LDKCVec_TxOutZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKTxOut arr_elem_conv = *(LDKTxOut*)(arr_elem_ptr);
- arr_elem_conv = TxOut_clone((LDKTxOut*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_TxOutZ CVec_TxOutZ_clone(const LDKCVec_TxOutZ *orig) {
LDKCVec_TxOutZ ret = { .data = MALLOC(sizeof(LDKTxOut) * orig->datalen, "LDKCVec_TxOutZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_TransactionNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_TransactionNoneZ*)arg)->result_ok;
-}
int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_TransactionNoneZ_get_ok(uint32_t arg) {
LDKCResult_TransactionNoneZ *val = (LDKCResult_TransactionNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_BlockHashChannelMonitorZZ_new(uint32_tArray elems) {
- LDKCVec_C2Tuple_BlockHashChannelMonitorZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ), "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ) * ret->datalen, "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_BlockHashChannelMonitorZ arr_elem_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_BlockHashChannelMonitorZ_clone((LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_BlockHashChannelMonitorZZ CVec_C2Tuple_BlockHashChannelMonitorZZ_clone(const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ *orig) {
LDKCVec_C2Tuple_BlockHashChannelMonitorZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ) * orig->datalen, "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)arg)->result_ok;
-}
uint32_tArray __attribute__((visibility("default"))) TS_LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_get_ok(uint32_t arg) {
LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ *val = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t script_ref = 0;
CHECK((((uint64_t)script_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&script_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(script_var);
script_ref = (uint64_t)script_var.inner & ~1;
return 0 /* LDKAPIError - IncompatibleShutdownScript */; (void) script_ref;
}
default: abort();
}
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneAPIErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NoneAPIErrorZ*)arg)->result_ok;
-}
void __attribute__((visibility("default"))) TS_LDKCResult_NoneAPIErrorZ_get_ok(uint32_t arg) {
LDKCResult_NoneAPIErrorZ *val = (LDKCResult_NoneAPIErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
return err_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_CResult_NoneAPIErrorZZ_new(uint32_tArray elems) {
- LDKCVec_CResult_NoneAPIErrorZZ *ret = MALLOC(sizeof(LDKCVec_CResult_NoneAPIErrorZZ), "LDKCVec_CResult_NoneAPIErrorZZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ) * ret->datalen, "LDKCVec_CResult_NoneAPIErrorZZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKCResult_NoneAPIErrorZ arr_elem_conv = *(LDKCResult_NoneAPIErrorZ*)(arr_elem_ptr);
- arr_elem_conv = CResult_NoneAPIErrorZ_clone((LDKCResult_NoneAPIErrorZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_CResult_NoneAPIErrorZZ CVec_CResult_NoneAPIErrorZZ_clone(const LDKCVec_CResult_NoneAPIErrorZZ *orig) {
LDKCVec_CResult_NoneAPIErrorZZ ret = { .data = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ) * orig->datalen, "LDKCVec_CResult_NoneAPIErrorZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_APIErrorZ_new(uint32_tArray elems) {
- LDKCVec_APIErrorZ *ret = MALLOC(sizeof(LDKCVec_APIErrorZ), "LDKCVec_APIErrorZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKAPIError) * ret->datalen, "LDKCVec_APIErrorZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKAPIError arr_elem_conv = *(LDKAPIError*)(arr_elem_ptr);
- arr_elem_conv = APIError_clone((LDKAPIError*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_APIErrorZ CVec_APIErrorZ_clone(const LDKCVec_APIErrorZ *orig) {
LDKCVec_APIErrorZ ret = { .data = MALLOC(sizeof(LDKAPIError) * orig->datalen, "LDKCVec_APIErrorZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult__u832APIErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult__u832APIErrorZ*)arg)->result_ok;
-}
int8_tArray __attribute__((visibility("default"))) TS_LDKCResult__u832APIErrorZ_get_ok(uint32_t arg) {
LDKCResult__u832APIErrorZ *val = (LDKCResult__u832APIErrorZ*)(arg & ~1);
CHECK(val->result_ok);
if ((uint64_t)failed_paths_retry_var.inner > 4096) {
CHECK((((uint64_t)failed_paths_retry_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&failed_paths_retry_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(failed_paths_retry_var);
failed_paths_retry_ref = (uint64_t)failed_paths_retry_var.inner & ~1;
}
int8_tArray payment_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
default: abort();
}
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_PaymentIdPaymentSendFailureZ_result_ok(uint32_t arg) {
- return ((LDKCResult_PaymentIdPaymentSendFailureZ*)arg)->result_ok;
-}
int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_PaymentIdPaymentSendFailureZ_get_ok(uint32_t arg) {
LDKCResult_PaymentIdPaymentSendFailureZ *val = (LDKCResult_PaymentIdPaymentSendFailureZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NonePaymentSendFailureZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NonePaymentSendFailureZ*)arg)->result_ok;
-}
void __attribute__((visibility("default"))) TS_LDKCResult_NonePaymentSendFailureZ_get_ok(uint32_t arg) {
LDKCResult_NonePaymentSendFailureZ *val = (LDKCResult_NonePaymentSendFailureZ*)(arg & ~1);
CHECK(val->result_ok);
return ret_arr;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_result_ok(uint32_t arg) {
- return ((LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(uint32_t arg) {
LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *val = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(arg & ~1);
CHECK(val->result_ok);
default: abort();
}
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_NetAddressZ_new(uint32_tArray elems) {
- LDKCVec_NetAddressZ *ret = MALLOC(sizeof(LDKCVec_NetAddressZ), "LDKCVec_NetAddressZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKNetAddress) * ret->datalen, "LDKCVec_NetAddressZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKNetAddress arr_elem_conv = *(LDKNetAddress*)(arr_elem_ptr);
- arr_elem_conv = NetAddress_clone((LDKNetAddress*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_NetAddressZ CVec_NetAddressZ_clone(const LDKCVec_NetAddressZ *orig) {
LDKCVec_NetAddressZ ret = { .data = MALLOC(sizeof(LDKNetAddress) * orig->datalen, "LDKCVec_NetAddressZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
return ret_arr;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_PaymentSecretAPIErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_PaymentSecretAPIErrorZ*)arg)->result_ok;
-}
int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_PaymentSecretAPIErrorZ_get_ok(uint32_t arg) {
LDKCResult_PaymentSecretAPIErrorZ *val = (LDKCResult_PaymentSecretAPIErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
return err_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_ChannelMonitorZ_new(uint32_tArray elems) {
- LDKCVec_ChannelMonitorZ *ret = MALLOC(sizeof(LDKCVec_ChannelMonitorZ), "LDKCVec_ChannelMonitorZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKChannelMonitor) * ret->datalen, "LDKCVec_ChannelMonitorZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKChannelMonitor arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = ChannelMonitor_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_ChannelMonitorZ CVec_ChannelMonitorZ_clone(const LDKCVec_ChannelMonitorZ *orig) {
LDKCVec_ChannelMonitorZ ret = { .data = MALLOC(sizeof(LDKChannelMonitor) * orig->datalen, "LDKCVec_ChannelMonitorZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
uint64_t funding_txo_ref = 0;
CHECK((((uint64_t)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
funding_txo_ref = (uint64_t)funding_txo_var.inner;
if (funding_txo_var.is_owned) {
funding_txo_ref |= 1;
uint64_t monitor_ref = 0;
CHECK((((uint64_t)monitor_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&monitor_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(monitor_var);
monitor_ref = (uint64_t)monitor_var.inner;
if (monitor_var.is_owned) {
monitor_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(ret_ptr);
- ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_NoneChannelMonitorUpdateErrZ update_channel_LDKWatch_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitorUpdate update) {
uint64_t funding_txo_ref = 0;
CHECK((((uint64_t)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
funding_txo_ref = (uint64_t)funding_txo_var.inner;
if (funding_txo_var.is_owned) {
funding_txo_ref |= 1;
uint64_t update_ref = 0;
CHECK((((uint64_t)update_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_var);
update_ref = (uint64_t)update_var.inner;
if (update_var.is_owned) {
update_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(ret_ptr);
- ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCVec_MonitorEventZ release_pending_monitor_events_LDKWatch_jcall(const void* this_arg) {
void* ret_conv_14_ptr = (void*)(((uint64_t)ret_conv_14) & ~1);
CHECK_ACCESS(ret_conv_14_ptr);
LDKMonitorEvent ret_conv_14_conv = *(LDKMonitorEvent*)(ret_conv_14_ptr);
- ret_conv_14_conv = MonitorEvent_clone((LDKMonitorEvent*)(((uint64_t)ret_conv_14) & ~1));
+ FREE((void*)ret_conv_14);
ret_constr.data[o] = ret_conv_14_conv;
}
return ret_constr;
LDKOutPoint funding_txo_conv;
funding_txo_conv.inner = (void*)(funding_txo & (~1));
funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
funding_txo_conv = OutPoint_clone(&funding_txo_conv);
LDKChannelMonitor monitor_conv;
monitor_conv.inner = (void*)(monitor & (~1));
monitor_conv.is_owned = (monitor & 1) || (monitor == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(monitor_conv);
monitor_conv = ChannelMonitor_clone(&monitor_conv);
LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
*ret_conv = (this_arg_conv->watch_channel)(this_arg_conv->this_arg, funding_txo_conv, monitor_conv);
LDKOutPoint funding_txo_conv;
funding_txo_conv.inner = (void*)(funding_txo & (~1));
funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
funding_txo_conv = OutPoint_clone(&funding_txo_conv);
LDKChannelMonitorUpdate update_conv;
update_conv.inner = (void*)(update & (~1));
update_conv.is_owned = (update & 1) || (update == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_conv);
update_conv = ChannelMonitorUpdate_clone(&update_conv);
LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
*ret_conv = (this_arg_conv->update_channel)(this_arg_conv->this_arg, funding_txo_conv, update_conv);
LDKShutdownScript ret_conv;
ret_conv.inner = (void*)(ret & (~1));
ret_conv.is_owned = (ret & 1) || (ret == 0);
- ret_conv = ShutdownScript_clone(&ret_conv);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
return ret_conv;
}
LDKSign get_channel_signer_LDKKeysInterface_jcall(const void* this_arg, bool inbound, uint64_t channel_value_satoshis) {
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKSign ret_conv = *(LDKSign*)(ret_ptr);
- ret_conv = Sign_clone(&ret_conv);
+ FREE((void*)ret);
return ret_conv;
}
LDKThirtyTwoBytes get_secure_random_bytes_LDKKeysInterface_jcall(const void* this_arg) {
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignDecodeErrorZ ret_conv = *(LDKCResult_SignDecodeErrorZ*)(ret_ptr);
- ret_conv = CResult_SignDecodeErrorZ_clone((LDKCResult_SignDecodeErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_RecoverableSignatureNoneZ sign_invoice_LDKKeysInterface_jcall(const void* this_arg, LDKCVec_u8Z invoice_preimage) {
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_RecoverableSignatureNoneZ ret_conv = *(LDKCResult_RecoverableSignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_RecoverableSignatureNoneZ_clone((LDKCResult_RecoverableSignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
static void LDKKeysInterface_JCalls_cloned(LDKKeysInterface* new_obj) {
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
FREE(j_calls);
}
}
-void log_LDKLogger_jcall(const void* this_arg, const char* record) {
+void log_LDKLogger_jcall(const void* this_arg, const LDKRecord * record) {
LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
- const char* record_str = record;
- jstring record_conv = str_ref_to_ts(record_str, strlen(record_str));
- js_invoke_function_1(j_calls->log_meth, record_conv);
+ LDKRecord record_var = *record;
+ uint64_t record_ref = 0;
+ record_var = Record_clone(record);
+ CHECK((((uint64_t)record_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&record_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(record_var);
+ record_ref = (uint64_t)record_var.inner;
+ if (record_var.is_owned) {
+ record_ref |= 1;
+ }
+ js_invoke_function_1(j_calls->log_meth, record_ref);
}
static void LDKLogger_JCalls_cloned(LDKLogger* new_obj) {
LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) new_obj->this_arg;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner & ~1;
return ret_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelConfigDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ChannelConfigDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelConfigDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ChannelConfigDecodeErrorZ *val = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_OutPointDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_OutPointDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_OutPointDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_OutPointDecodeErrorZ *val = (LDKCResult_OutPointDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
default: abort();
}
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_COption_TypeZDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_COption_TypeZDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_COption_TypeZDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_COption_TypeZDecodeErrorZ *val = (LDKCResult_COption_TypeZDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
uint64_t routing_ref = 0;
CHECK((((uint64_t)routing_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&routing_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(routing_var);
routing_ref = (uint64_t)routing_var.inner & ~1;
return 0 /* LDKPaymentError - Routing */; (void) routing_ref;
}
default: abort();
}
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_PaymentIdPaymentErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_PaymentIdPaymentErrorZ*)arg)->result_ok;
-}
int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_PaymentIdPaymentErrorZ_get_ok(uint32_t arg) {
LDKCResult_PaymentIdPaymentErrorZ *val = (LDKCResult_PaymentIdPaymentErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_SiPrefixNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_SiPrefixNoneZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_SiPrefixNoneZ_get_ok(uint32_t arg) {
LDKCResult_SiPrefixNoneZ *val = (LDKCResult_SiPrefixNoneZ*)(arg & ~1);
CHECK(val->result_ok);
CHECK(!val->result_ok);
return *val->contents.err;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_InvoiceNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_InvoiceNoneZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InvoiceNoneZ_get_ok(uint32_t arg) {
LDKCResult_InvoiceNoneZ *val = (LDKCResult_InvoiceNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
CHECK(!val->result_ok);
return *val->contents.err;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_SignedRawInvoiceNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_SignedRawInvoiceNoneZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_SignedRawInvoiceNoneZ_get_ok(uint32_t arg) {
LDKCResult_SignedRawInvoiceNoneZ *val = (LDKCResult_SignedRawInvoiceNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_PayeePubKeyErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_PayeePubKeyErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PayeePubKeyErrorZ_get_ok(uint32_t arg) {
LDKCResult_PayeePubKeyErrorZ *val = (LDKCResult_PayeePubKeyErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint32_t err_conv = LDKSecp256k1Error_to_js((*val->contents.err));
return err_conv;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_PrivateRouteZ_new(uint32_tArray elems) {
- LDKCVec_PrivateRouteZ *ret = MALLOC(sizeof(LDKCVec_PrivateRouteZ), "LDKCVec_PrivateRouteZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKPrivateRoute) * ret->datalen, "LDKCVec_PrivateRouteZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKPrivateRoute arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = PrivateRoute_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_PrivateRouteZ CVec_PrivateRouteZ_clone(const LDKCVec_PrivateRouteZ *orig) {
LDKCVec_PrivateRouteZ ret = { .data = MALLOC(sizeof(LDKPrivateRoute) * orig->datalen, "LDKCVec_PrivateRouteZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_PositiveTimestampCreationErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_PositiveTimestampCreationErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PositiveTimestampCreationErrorZ_get_ok(uint32_t arg) {
LDKCResult_PositiveTimestampCreationErrorZ *val = (LDKCResult_PositiveTimestampCreationErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint32_t err_conv = LDKCreationError_to_js((*val->contents.err));
return err_conv;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneSemanticErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NoneSemanticErrorZ*)arg)->result_ok;
-}
void __attribute__((visibility("default"))) TS_LDKCResult_NoneSemanticErrorZ_get_ok(uint32_t arg) {
LDKCResult_NoneSemanticErrorZ *val = (LDKCResult_NoneSemanticErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint32_t err_conv = LDKSemanticError_to_js((*val->contents.err));
return err_conv;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_InvoiceSemanticErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_InvoiceSemanticErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InvoiceSemanticErrorZ_get_ok(uint32_t arg) {
LDKCResult_InvoiceSemanticErrorZ *val = (LDKCResult_InvoiceSemanticErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint32_t err_conv = LDKSemanticError_to_js((*val->contents.err));
return err_conv;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_DescriptionCreationErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_DescriptionCreationErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_DescriptionCreationErrorZ_get_ok(uint32_t arg) {
LDKCResult_DescriptionCreationErrorZ *val = (LDKCResult_DescriptionCreationErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint32_t err_conv = LDKCreationError_to_js((*val->contents.err));
return err_conv;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ExpiryTimeCreationErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ExpiryTimeCreationErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ExpiryTimeCreationErrorZ_get_ok(uint32_t arg) {
LDKCResult_ExpiryTimeCreationErrorZ *val = (LDKCResult_ExpiryTimeCreationErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint32_t err_conv = LDKCreationError_to_js((*val->contents.err));
return err_conv;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_PrivateRouteCreationErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_PrivateRouteCreationErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PrivateRouteCreationErrorZ_get_ok(uint32_t arg) {
LDKCResult_PrivateRouteCreationErrorZ *val = (LDKCResult_PrivateRouteCreationErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint32_t err_conv = LDKCreationError_to_js((*val->contents.err));
return err_conv;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_StringErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_StringErrorZ*)arg)->result_ok;
-}
jstring __attribute__((visibility("default"))) TS_LDKCResult_StringErrorZ_get_ok(uint32_t arg) {
LDKCResult_StringErrorZ *val = (LDKCResult_StringErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint32_t err_conv = LDKSecp256k1Error_to_js((*val->contents.err));
return err_conv;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelMonitorUpdateDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ChannelMonitorUpdateDecodeErrorZ *val = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_HTLCUpdateDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_HTLCUpdateDecodeErrorZ*)arg)->result_ok;
+uint32_t __attribute__((visibility("default"))) TS_LDKCOption_MonitorEventZ_ref_from_ptr(uint32_t ptr) {
+ LDKCOption_MonitorEventZ *obj = (LDKCOption_MonitorEventZ*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKCOption_MonitorEventZ_Some: {
+ uint64_t some_ref = ((uint64_t)&obj->some) | 1;
+ return 0 /* LDKCOption_MonitorEventZ - Some */; (void) some_ref;
+ }
+ case LDKCOption_MonitorEventZ_None: {
+ return 0 /* LDKCOption_MonitorEventZ - None */;
+ }
+ default: abort();
+ }
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCResult_COption_MonitorEventZDecodeErrorZ_get_ok(uint32_t arg) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ *val = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(arg & ~1);
+ CHECK(val->result_ok);
+ uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
+ return res_ref;
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCResult_COption_MonitorEventZDecodeErrorZ_get_err(uint32_t arg) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ *val = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(arg & ~1);
+ CHECK(!val->result_ok);
+ LDKDecodeError err_var = (*val->contents.err);
+ uint64_t err_ref = 0;
+ CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
+ err_ref = (uint64_t)err_var.inner & ~1;
+ return err_ref;
}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_HTLCUpdateDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_HTLCUpdateDecodeErrorZ *val = (LDKCResult_HTLCUpdateDecodeErrorZ*)(arg & ~1);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneMonitorUpdateErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NoneMonitorUpdateErrorZ*)arg)->result_ok;
-}
void __attribute__((visibility("default"))) TS_LDKCResult_NoneMonitorUpdateErrorZ_get_ok(uint32_t arg) {
LDKCResult_NoneMonitorUpdateErrorZ *val = (LDKCResult_NoneMonitorUpdateErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_arr;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_u32ScriptZZ_new(uint32_tArray elems) {
- LDKCVec_C2Tuple_u32ScriptZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_u32ScriptZZ), "LDKCVec_C2Tuple_u32ScriptZZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ) * ret->datalen, "LDKCVec_C2Tuple_u32ScriptZZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_u32ScriptZ arr_elem_conv = *(LDKC2Tuple_u32ScriptZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_u32ScriptZ_clone((LDKC2Tuple_u32ScriptZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_u32ScriptZZ CVec_C2Tuple_u32ScriptZZ_clone(const LDKCVec_C2Tuple_u32ScriptZZ *orig) {
LDKCVec_C2Tuple_u32ScriptZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ) * orig->datalen, "LDKCVec_C2Tuple_u32ScriptZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
return ret_arr;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_new(uint32_tArray elems) {
- LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ) * ret->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ arr_elem_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone((LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_clone(const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ *orig) {
LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ) * orig->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKPaymentPurpose_ref_from_ptr(uint32_t ptr) {
- LDKPaymentPurpose *obj = (LDKPaymentPurpose*)(ptr & ~1);
- switch(obj->tag) {
- case LDKPaymentPurpose_InvoicePayment: {
- int8_tArray payment_preimage_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(payment_preimage_arr + 4), obj->invoice_payment.payment_preimage.data, 32);
- int8_tArray payment_secret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(payment_secret_arr + 4), obj->invoice_payment.payment_secret.data, 32);
- return 0 /* LDKPaymentPurpose - InvoicePayment */; (void) payment_preimage_arr; (void) payment_secret_arr; (void) obj->invoice_payment.user_payment_id;
- }
- case LDKPaymentPurpose_SpontaneousPayment: {
- int8_tArray spontaneous_payment_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(spontaneous_payment_arr + 4), obj->spontaneous_payment.data, 32);
- return 0 /* LDKPaymentPurpose - SpontaneousPayment */; (void) spontaneous_payment_arr;
- }
- default: abort();
- }
-}
-uint32_t __attribute__((visibility("default"))) TS_LDKClosureReason_ref_from_ptr(uint32_t ptr) {
- LDKClosureReason *obj = (LDKClosureReason*)(ptr & ~1);
- switch(obj->tag) {
- case LDKClosureReason_CounterpartyForceClosed: {
- LDKStr peer_msg_str = obj->counterparty_force_closed.peer_msg;
- jstring peer_msg_conv = str_ref_to_ts(peer_msg_str.chars, peer_msg_str.len);
- return 0 /* LDKClosureReason - CounterpartyForceClosed */; (void) peer_msg_conv;
- }
- case LDKClosureReason_HolderForceClosed: {
- return 0 /* LDKClosureReason - HolderForceClosed */;
- }
- case LDKClosureReason_CooperativeClosure: {
- return 0 /* LDKClosureReason - CooperativeClosure */;
- }
- case LDKClosureReason_CommitmentTxConfirmed: {
- return 0 /* LDKClosureReason - CommitmentTxConfirmed */;
- }
- case LDKClosureReason_ProcessingError: {
- LDKStr err_str = obj->processing_error.err;
- jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
- return 0 /* LDKClosureReason - ProcessingError */; (void) err_conv;
- }
- case LDKClosureReason_DisconnectedPeer: {
- return 0 /* LDKClosureReason - DisconnectedPeer */;
- }
- case LDKClosureReason_OutdatedChannelManager: {
- return 0 /* LDKClosureReason - OutdatedChannelManager */;
- }
- default: abort();
- }
-}
-uint32_t __attribute__((visibility("default"))) TS_LDKEvent_ref_from_ptr(uint32_t ptr) {
- LDKEvent *obj = (LDKEvent*)(ptr & ~1);
- switch(obj->tag) {
- case LDKEvent_FundingGenerationReady: {
- int8_tArray temporary_channel_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(temporary_channel_id_arr + 4), obj->funding_generation_ready.temporary_channel_id.data, 32);
- LDKCVec_u8Z output_script_var = obj->funding_generation_ready.output_script;
- int8_tArray output_script_arr = init_arr(output_script_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(output_script_arr + 4), output_script_var.data, output_script_var.datalen);
- return 0 /* LDKEvent - FundingGenerationReady */; (void) temporary_channel_id_arr; (void) obj->funding_generation_ready.channel_value_satoshis; (void) output_script_arr; (void) obj->funding_generation_ready.user_channel_id;
- }
- case LDKEvent_PaymentReceived: {
- int8_tArray payment_hash_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(payment_hash_arr + 4), obj->payment_received.payment_hash.data, 32);
- uint64_t purpose_ref = ((uint64_t)&obj->payment_received.purpose) | 1;
- return 0 /* LDKEvent - PaymentReceived */; (void) payment_hash_arr; (void) obj->payment_received.amt; (void) purpose_ref;
- }
- case LDKEvent_PaymentSent: {
- int8_tArray payment_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(payment_id_arr + 4), obj->payment_sent.payment_id.data, 32);
- int8_tArray payment_preimage_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(payment_preimage_arr + 4), obj->payment_sent.payment_preimage.data, 32);
- int8_tArray payment_hash_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(payment_hash_arr + 4), obj->payment_sent.payment_hash.data, 32);
- uint64_t fee_paid_msat_ref = ((uint64_t)&obj->payment_sent.fee_paid_msat) | 1;
- return 0 /* LDKEvent - PaymentSent */; (void) payment_id_arr; (void) payment_preimage_arr; (void) payment_hash_arr; (void) fee_paid_msat_ref;
- }
- case LDKEvent_PaymentPathFailed: {
- int8_tArray payment_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(payment_id_arr + 4), obj->payment_path_failed.payment_id.data, 32);
- int8_tArray payment_hash_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(payment_hash_arr + 4), obj->payment_path_failed.payment_hash.data, 32);
- uint64_t network_update_ref = ((uint64_t)&obj->payment_path_failed.network_update) | 1;
- LDKCVec_RouteHopZ path_var = obj->payment_path_failed.path;
- uint32_tArray path_arr = NULL;
- path_arr = init_arr(path_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
- uint32_t *path_arr_ptr = (uint32_t*)(path_arr + 4);
- for (size_t k = 0; k < path_var.datalen; k++) {
- LDKRouteHop path_conv_10_var = path_var.data[k];
- uint64_t path_conv_10_ref = 0;
- CHECK((((uint64_t)path_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
- CHECK((((uint64_t)&path_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
- path_conv_10_ref = (uint64_t)path_conv_10_var.inner & ~1;
- path_arr_ptr[k] = path_conv_10_ref;
- }
-
- uint64_t short_channel_id_ref = ((uint64_t)&obj->payment_path_failed.short_channel_id) | 1;
- LDKRouteParameters retry_var = obj->payment_path_failed.retry;
- uint64_t retry_ref = 0;
- if ((uint64_t)retry_var.inner > 4096) {
- CHECK((((uint64_t)retry_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
- CHECK((((uint64_t)&retry_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
- retry_ref = (uint64_t)retry_var.inner & ~1;
- }
- return 0 /* LDKEvent - PaymentPathFailed */; (void) payment_id_arr; (void) payment_hash_arr; (void) obj->payment_path_failed.rejected_by_dest; (void) network_update_ref; (void) obj->payment_path_failed.all_paths_failed; (void) path_arr; (void) short_channel_id_ref; (void) retry_ref;
- }
- case LDKEvent_PendingHTLCsForwardable: {
- return 0 /* LDKEvent - PendingHTLCsForwardable */; (void) obj->pending_htl_cs_forwardable.time_forwardable;
- }
- case LDKEvent_SpendableOutputs: {
- LDKCVec_SpendableOutputDescriptorZ outputs_var = obj->spendable_outputs.outputs;
- uint32_tArray outputs_arr = NULL;
- outputs_arr = init_arr(outputs_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
- uint32_t *outputs_arr_ptr = (uint32_t*)(outputs_arr + 4);
- for (size_t b = 0; b < outputs_var.datalen; b++) {
- uint64_t outputs_conv_27_ref = ((uint64_t)&outputs_var.data[b]) | 1;
- outputs_arr_ptr[b] = outputs_conv_27_ref;
- }
-
- return 0 /* LDKEvent - SpendableOutputs */; (void) outputs_arr;
- }
- case LDKEvent_PaymentForwarded: {
- uint64_t fee_earned_msat_ref = ((uint64_t)&obj->payment_forwarded.fee_earned_msat) | 1;
- return 0 /* LDKEvent - PaymentForwarded */; (void) fee_earned_msat_ref; (void) obj->payment_forwarded.claim_from_onchain_tx;
- }
- case LDKEvent_ChannelClosed: {
- int8_tArray channel_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(channel_id_arr + 4), obj->channel_closed.channel_id.data, 32);
- uint64_t reason_ref = ((uint64_t)&obj->channel_closed.reason) | 1;
- return 0 /* LDKEvent - ChannelClosed */; (void) channel_id_arr; (void) obj->channel_closed.user_channel_id; (void) reason_ref;
- }
- case LDKEvent_DiscardFunding: {
- int8_tArray channel_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(channel_id_arr + 4), obj->discard_funding.channel_id.data, 32);
- LDKTransaction transaction_var = obj->discard_funding.transaction;
- int8_tArray transaction_arr = init_arr(transaction_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(transaction_arr + 4), transaction_var.data, transaction_var.datalen);
- return 0 /* LDKEvent - DiscardFunding */; (void) channel_id_arr; (void) transaction_arr;
- }
- default: abort();
- }
-}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_EventZ_new(uint32_tArray elems) {
- LDKCVec_EventZ *ret = MALLOC(sizeof(LDKCVec_EventZ), "LDKCVec_EventZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKEvent) * ret->datalen, "LDKCVec_EventZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKEvent arr_elem_conv = *(LDKEvent*)(arr_elem_ptr);
- arr_elem_conv = Event_clone((LDKEvent*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_EventZ CVec_EventZ_clone(const LDKCVec_EventZ *orig) {
LDKCVec_EventZ ret = { .data = MALLOC(sizeof(LDKEvent) * orig->datalen, "LDKCVec_EventZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
return (uint64_t)ret_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_u32TxOutZZ_new(uint32_tArray elems) {
- LDKCVec_C2Tuple_u32TxOutZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_u32TxOutZZ), "LDKCVec_C2Tuple_u32TxOutZZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ) * ret->datalen, "LDKCVec_C2Tuple_u32TxOutZZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_u32TxOutZ arr_elem_conv = *(LDKC2Tuple_u32TxOutZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_u32TxOutZ_clone((LDKC2Tuple_u32TxOutZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_u32TxOutZZ CVec_C2Tuple_u32TxOutZZ_clone(const LDKCVec_C2Tuple_u32TxOutZZ *orig) {
LDKCVec_C2Tuple_u32TxOutZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ) * orig->datalen, "LDKCVec_C2Tuple_u32TxOutZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
return ret_arr;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_new(uint32_tArray elems) {
- LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ) * ret->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ arr_elem_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone((LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_clone(const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ *orig) {
LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ) * orig->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
default: abort();
}
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_BalanceZ_new(uint32_tArray elems) {
- LDKCVec_BalanceZ *ret = MALLOC(sizeof(LDKCVec_BalanceZ), "LDKCVec_BalanceZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKBalance) * ret->datalen, "LDKCVec_BalanceZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKBalance arr_elem_conv = *(LDKBalance*)(arr_elem_ptr);
- arr_elem_conv = Balance_clone((LDKBalance*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_BalanceZ CVec_BalanceZ_clone(const LDKCVec_BalanceZ *orig) {
LDKCVec_BalanceZ ret = { .data = MALLOC(sizeof(LDKBalance) * orig->datalen, "LDKCVec_BalanceZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneLightningErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NoneLightningErrorZ*)arg)->result_ok;
-}
void __attribute__((visibility("default"))) TS_LDKCResult_NoneLightningErrorZ_get_ok(uint32_t arg) {
LDKCResult_NoneLightningErrorZ *val = (LDKCResult_NoneLightningErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
return (uint64_t)ret_ret;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_PublicKeyTypeZZ_new(uint32_tArray elems) {
- LDKCVec_C2Tuple_PublicKeyTypeZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_PublicKeyTypeZZ), "LDKCVec_C2Tuple_PublicKeyTypeZZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ) * ret->datalen, "LDKCVec_C2Tuple_PublicKeyTypeZZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_PublicKeyTypeZ arr_elem_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_PublicKeyTypeZ_clone((LDKC2Tuple_PublicKeyTypeZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_PublicKeyTypeZZ CVec_C2Tuple_PublicKeyTypeZZ_clone(const LDKCVec_C2Tuple_PublicKeyTypeZZ *orig) {
LDKCVec_C2Tuple_PublicKeyTypeZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ) * orig->datalen, "LDKCVec_C2Tuple_PublicKeyTypeZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_boolLightningErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_boolLightningErrorZ*)arg)->result_ok;
-}
jboolean __attribute__((visibility("default"))) TS_LDKCResult_boolLightningErrorZ_get_ok(uint32_t arg) {
LDKCResult_boolLightningErrorZ *val = (LDKCResult_boolLightningErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_new(uint32_tArray elems) {
- LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret = MALLOC(sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) * ret->datalen, "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ arr_elem_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(arr_elem_ptr);
- arr_elem_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone((LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *orig) {
LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret = { .data = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) * orig->datalen, "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_NodeAnnouncementZ_new(uint32_tArray elems) {
- LDKCVec_NodeAnnouncementZ *ret = MALLOC(sizeof(LDKCVec_NodeAnnouncementZ), "LDKCVec_NodeAnnouncementZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKNodeAnnouncement) * ret->datalen, "LDKCVec_NodeAnnouncementZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKNodeAnnouncement arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = NodeAnnouncement_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_NodeAnnouncementZ CVec_NodeAnnouncementZ_clone(const LDKCVec_NodeAnnouncementZ *orig) {
LDKCVec_NodeAnnouncementZ ret = { .data = MALLOC(sizeof(LDKNodeAnnouncement) * orig->datalen, "LDKCVec_NodeAnnouncementZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_CVec_u8ZPeerHandleErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_CVec_u8ZPeerHandleErrorZ*)arg)->result_ok;
-}
int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_CVec_u8ZPeerHandleErrorZ_get_ok(uint32_t arg) {
LDKCResult_CVec_u8ZPeerHandleErrorZ *val = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NonePeerHandleErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NonePeerHandleErrorZ*)arg)->result_ok;
-}
void __attribute__((visibility("default"))) TS_LDKCResult_NonePeerHandleErrorZ_get_ok(uint32_t arg) {
LDKCResult_NonePeerHandleErrorZ *val = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_boolPeerHandleErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_boolPeerHandleErrorZ*)arg)->result_ok;
-}
jboolean __attribute__((visibility("default"))) TS_LDKCResult_boolPeerHandleErrorZ_get_ok(uint32_t arg) {
LDKCResult_boolPeerHandleErrorZ *val = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NodeIdDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NodeIdDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NodeIdDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_NodeIdDecodeErrorZ *val = (LDKCResult_NodeIdDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
+ err_ref = (uint64_t)err_var.inner & ~1;
+ return err_ref;
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(uint32_t arg) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ *val = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(arg & ~1);
+ CHECK(val->result_ok);
+ uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
+ return res_ref;
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCResult_COption_NetworkUpdateZDecodeErrorZ_get_err(uint32_t arg) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ *val = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(arg & ~1);
+ CHECK(!val->result_ok);
+ LDKDecodeError err_var = (*val->contents.err);
+ uint64_t err_ref = 0;
+ CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_TxOutAccessErrorZ ret_conv = *(LDKCResult_TxOutAccessErrorZ*)(ret_ptr);
- ret_conv = CResult_TxOutAccessErrorZ_clone((LDKCResult_TxOutAccessErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
static void LDKAccess_JCalls_cloned(LDKAccess* new_obj) {
default: abort();
}
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_DirectionalChannelInfoDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_DirectionalChannelInfoDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_DirectionalChannelInfoDecodeErrorZ *val = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelInfoDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ChannelInfoDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelInfoDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ChannelInfoDecodeErrorZ *val = (LDKCResult_ChannelInfoDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_RoutingFeesDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_RoutingFeesDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RoutingFeesDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_RoutingFeesDecodeErrorZ *val = (LDKCResult_RoutingFeesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NodeAnnouncementInfoDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_NodeAnnouncementInfoDecodeErrorZ *val = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_u64Z_new(int64_tArray elems) {
- LDKCVec_u64Z *ret = MALLOC(sizeof(LDKCVec_u64Z), "LDKCVec_u64Z");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(uint64_t) * ret->datalen, "LDKCVec_u64Z Data");
- int64_t *java_elems = (int64_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- ret->data[i] = java_elems[i];
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_u64Z CVec_u64Z_clone(const LDKCVec_u64Z *orig) {
LDKCVec_u64Z ret = { .data = MALLOC(sizeof(int64_t) * orig->datalen, "LDKCVec_u64Z clone bytes"), .datalen = orig->datalen };
memcpy(ret.data, orig->data, sizeof(int64_t) * ret.datalen);
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NodeInfoDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NodeInfoDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NodeInfoDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_NodeInfoDecodeErrorZ *val = (LDKCResult_NodeInfoDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NetworkGraphDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NetworkGraphDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NetworkGraphDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_NetworkGraphDecodeErrorZ *val = (LDKCResult_NetworkGraphDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
default: abort();
}
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NetAddressDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NetAddressDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NetAddressDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_NetAddressDecodeErrorZ *val = (LDKCResult_NetAddressDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_UpdateAddHTLCZ_new(uint32_tArray elems) {
- LDKCVec_UpdateAddHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateAddHTLCZ), "LDKCVec_UpdateAddHTLCZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKUpdateAddHTLC) * ret->datalen, "LDKCVec_UpdateAddHTLCZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKUpdateAddHTLC arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = UpdateAddHTLC_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_UpdateAddHTLCZ CVec_UpdateAddHTLCZ_clone(const LDKCVec_UpdateAddHTLCZ *orig) {
LDKCVec_UpdateAddHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateAddHTLC) * orig->datalen, "LDKCVec_UpdateAddHTLCZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_UpdateFulfillHTLCZ_new(uint32_tArray elems) {
- LDKCVec_UpdateFulfillHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateFulfillHTLCZ), "LDKCVec_UpdateFulfillHTLCZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKUpdateFulfillHTLC) * ret->datalen, "LDKCVec_UpdateFulfillHTLCZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKUpdateFulfillHTLC arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = UpdateFulfillHTLC_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_UpdateFulfillHTLCZ CVec_UpdateFulfillHTLCZ_clone(const LDKCVec_UpdateFulfillHTLCZ *orig) {
LDKCVec_UpdateFulfillHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFulfillHTLC) * orig->datalen, "LDKCVec_UpdateFulfillHTLCZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_UpdateFailHTLCZ_new(uint32_tArray elems) {
- LDKCVec_UpdateFailHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateFailHTLCZ), "LDKCVec_UpdateFailHTLCZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKUpdateFailHTLC) * ret->datalen, "LDKCVec_UpdateFailHTLCZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKUpdateFailHTLC arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = UpdateFailHTLC_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_UpdateFailHTLCZ CVec_UpdateFailHTLCZ_clone(const LDKCVec_UpdateFailHTLCZ *orig) {
LDKCVec_UpdateFailHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailHTLC) * orig->datalen, "LDKCVec_UpdateFailHTLCZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_UpdateFailMalformedHTLCZ_new(uint32_tArray elems) {
- LDKCVec_UpdateFailMalformedHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateFailMalformedHTLCZ), "LDKCVec_UpdateFailMalformedHTLCZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKUpdateFailMalformedHTLC) * ret->datalen, "LDKCVec_UpdateFailMalformedHTLCZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKUpdateFailMalformedHTLC arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = UpdateFailMalformedHTLC_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_UpdateFailMalformedHTLCZ CVec_UpdateFailMalformedHTLCZ_clone(const LDKCVec_UpdateFailMalformedHTLCZ *orig) {
LDKCVec_UpdateFailMalformedHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailMalformedHTLC) * orig->datalen, "LDKCVec_UpdateFailMalformedHTLCZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_AcceptChannelDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_AcceptChannelDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_AcceptChannelDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_AcceptChannelDecodeErrorZ *val = (LDKCResult_AcceptChannelDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_AnnouncementSignaturesDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_AnnouncementSignaturesDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_AnnouncementSignaturesDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_AnnouncementSignaturesDecodeErrorZ *val = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelReestablishDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ChannelReestablishDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelReestablishDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ChannelReestablishDecodeErrorZ *val = (LDKCResult_ChannelReestablishDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ClosingSignedDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ClosingSignedDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ClosingSignedDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ClosingSignedDecodeErrorZ *val = (LDKCResult_ClosingSignedDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ClosingSignedFeeRangeDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *val = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_CommitmentSignedDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_CommitmentSignedDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_CommitmentSignedDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_CommitmentSignedDecodeErrorZ *val = (LDKCResult_CommitmentSignedDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_FundingCreatedDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_FundingCreatedDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_FundingCreatedDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_FundingCreatedDecodeErrorZ *val = (LDKCResult_FundingCreatedDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_FundingSignedDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_FundingSignedDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_FundingSignedDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_FundingSignedDecodeErrorZ *val = (LDKCResult_FundingSignedDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_FundingLockedDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_FundingLockedDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_FundingLockedDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_FundingLockedDecodeErrorZ *val = (LDKCResult_FundingLockedDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_InitDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_InitDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InitDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_InitDecodeErrorZ *val = (LDKCResult_InitDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_OpenChannelDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_OpenChannelDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_OpenChannelDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_OpenChannelDecodeErrorZ *val = (LDKCResult_OpenChannelDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_RevokeAndACKDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_RevokeAndACKDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RevokeAndACKDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_RevokeAndACKDecodeErrorZ *val = (LDKCResult_RevokeAndACKDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ShutdownDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ShutdownDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ShutdownDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ShutdownDecodeErrorZ *val = (LDKCResult_ShutdownDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_UpdateFailHTLCDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_UpdateFailHTLCDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UpdateFailHTLCDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_UpdateFailHTLCDecodeErrorZ *val = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *val = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_UpdateFeeDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_UpdateFeeDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UpdateFeeDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_UpdateFeeDecodeErrorZ *val = (LDKCResult_UpdateFeeDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_UpdateFulfillHTLCDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_UpdateFulfillHTLCDecodeErrorZ *val = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_UpdateAddHTLCDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_UpdateAddHTLCDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UpdateAddHTLCDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_UpdateAddHTLCDecodeErrorZ *val = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_PingDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_PingDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PingDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_PingDecodeErrorZ *val = (LDKCResult_PingDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_PongDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_PongDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PongDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_PongDecodeErrorZ *val = (LDKCResult_PongDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *val = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelAnnouncementDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ChannelAnnouncementDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelAnnouncementDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ChannelAnnouncementDecodeErrorZ *val = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_UnsignedChannelUpdateDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_UnsignedChannelUpdateDecodeErrorZ *val = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelUpdateDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ChannelUpdateDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelUpdateDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ChannelUpdateDecodeErrorZ *val = (LDKCResult_ChannelUpdateDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ErrorMessageDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ErrorMessageDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ErrorMessageDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ErrorMessageDecodeErrorZ *val = (LDKCResult_ErrorMessageDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *val = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NodeAnnouncementDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NodeAnnouncementDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NodeAnnouncementDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_NodeAnnouncementDecodeErrorZ *val = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_QueryShortChannelIdsDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_QueryShortChannelIdsDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_QueryShortChannelIdsDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_QueryShortChannelIdsDecodeErrorZ *val = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *val = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_QueryChannelRangeDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_QueryChannelRangeDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_QueryChannelRangeDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_QueryChannelRangeDecodeErrorZ *val = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ReplyChannelRangeDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ReplyChannelRangeDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ReplyChannelRangeDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ReplyChannelRangeDecodeErrorZ *val = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_GossipTimestampFilterDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_GossipTimestampFilterDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_GossipTimestampFilterDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_GossipTimestampFilterDecodeErrorZ *val = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
default: abort();
}
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_InvoiceSignOrCreationErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_InvoiceSignOrCreationErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InvoiceSignOrCreationErrorZ_get_ok(uint32_t arg) {
LDKCResult_InvoiceSignOrCreationErrorZ *val = (LDKCResult_InvoiceSignOrCreationErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t output_ref = 0;
CHECK((((uint64_t)output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(output_var);
output_ref = (uint64_t)output_var.inner;
if (output_var.is_owned) {
output_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCOption_C2Tuple_usizeTransactionZZ ret_conv = *(LDKCOption_C2Tuple_usizeTransactionZZ*)(ret_ptr);
- ret_conv = COption_C2Tuple_usizeTransactionZZ_clone((LDKCOption_C2Tuple_usizeTransactionZZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
static void LDKFilter_JCalls_cloned(LDKFilter* new_obj) {
LDKWatchedOutput output_conv;
output_conv.inner = (void*)(output & (~1));
output_conv.is_owned = (output & 1) || (output == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(output_conv);
output_conv = WatchedOutput_clone(&output_conv);
LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
*ret_copy = (this_arg_conv->register_output)(this_arg_conv->this_arg, output_conv);
default: abort();
}
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_LockedChannelMonitorNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_LockedChannelMonitorNoneZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_LockedChannelMonitorNoneZ_get_ok(uint32_t arg) {
LDKCResult_LockedChannelMonitorNoneZ *val = (LDKCResult_LockedChannelMonitorNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
CHECK(!val->result_ok);
return *val->contents.err;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_OutPointZ_new(uint32_tArray elems) {
- LDKCVec_OutPointZ *ret = MALLOC(sizeof(LDKCVec_OutPointZ), "LDKCVec_OutPointZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKOutPoint) * ret->datalen, "LDKCVec_OutPointZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKOutPoint arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = OutPoint_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_OutPointZ CVec_OutPointZ_clone(const LDKCVec_OutPointZ *orig) {
LDKCVec_OutPointZ ret = { .data = MALLOC(sizeof(LDKOutPoint) * orig->datalen, "LDKCVec_OutPointZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
void* ret_conv_18_ptr = (void*)(((uint64_t)ret_conv_18) & ~1);
CHECK_ACCESS(ret_conv_18_ptr);
LDKMessageSendEvent ret_conv_18_conv = *(LDKMessageSendEvent*)(ret_conv_18_ptr);
- ret_conv_18_conv = MessageSendEvent_clone((LDKMessageSendEvent*)(((uint64_t)ret_conv_18) & ~1));
+ FREE((void*)ret_conv_18);
ret_constr.data[s] = ret_conv_18_conv;
}
return ret_constr;
uint64_t channel_id_ref = 0;
CHECK((((uint64_t)channel_id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&channel_id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_var);
channel_id_ref = (uint64_t)channel_id_var.inner;
if (channel_id_var.is_owned) {
channel_id_ref |= 1;
data_var = ChannelMonitor_clone(data);
CHECK((((uint64_t)data_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&data_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(data_var);
data_ref = (uint64_t)data_var.inner;
if (data_var.is_owned) {
data_ref |= 1;
uint64_t update_id_ref = 0;
CHECK((((uint64_t)update_id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_var);
update_id_ref = (uint64_t)update_id_var.inner;
if (update_id_var.is_owned) {
update_id_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(ret_ptr);
- ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_NoneChannelMonitorUpdateErrZ update_persisted_channel_LDKPersist_jcall(const void* this_arg, LDKOutPoint channel_id, const LDKChannelMonitorUpdate * update, const LDKChannelMonitor * data, LDKMonitorUpdateId update_id) {
uint64_t channel_id_ref = 0;
CHECK((((uint64_t)channel_id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&channel_id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_var);
channel_id_ref = (uint64_t)channel_id_var.inner;
if (channel_id_var.is_owned) {
channel_id_ref |= 1;
update_var = ChannelMonitorUpdate_clone(update);
CHECK((((uint64_t)update_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_var);
update_ref = (uint64_t)update_var.inner;
if (update_var.is_owned) {
update_ref |= 1;
data_var = ChannelMonitor_clone(data);
CHECK((((uint64_t)data_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&data_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(data_var);
data_ref = (uint64_t)data_var.inner;
if (data_var.is_owned) {
data_ref |= 1;
uint64_t update_id_ref = 0;
CHECK((((uint64_t)update_id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_var);
update_id_ref = (uint64_t)update_id_var.inner;
if (update_id_var.is_owned) {
update_id_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(ret_ptr);
- ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
static void LDKPersist_JCalls_cloned(LDKPersist* new_obj) {
LDKOutPoint channel_id_conv;
channel_id_conv.inner = (void*)(channel_id & (~1));
channel_id_conv.is_owned = (channel_id & 1) || (channel_id == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_conv);
channel_id_conv = OutPoint_clone(&channel_id_conv);
LDKChannelMonitor data_conv;
data_conv.inner = (void*)(data & (~1));
data_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(data_conv);
LDKMonitorUpdateId update_id_conv;
update_id_conv.inner = (void*)(update_id & (~1));
update_id_conv.is_owned = (update_id & 1) || (update_id == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_conv);
update_id_conv = MonitorUpdateId_clone(&update_id_conv);
LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
*ret_conv = (this_arg_conv->persist_new_channel)(this_arg_conv->this_arg, channel_id_conv, &data_conv, update_id_conv);
LDKOutPoint channel_id_conv;
channel_id_conv.inner = (void*)(channel_id & (~1));
channel_id_conv.is_owned = (channel_id & 1) || (channel_id == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_conv);
channel_id_conv = OutPoint_clone(&channel_id_conv);
LDKChannelMonitorUpdate update_conv;
update_conv.inner = (void*)(update & (~1));
update_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_conv);
LDKChannelMonitor data_conv;
data_conv.inner = (void*)(data & (~1));
data_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(data_conv);
LDKMonitorUpdateId update_id_conv;
update_id_conv.inner = (void*)(update_id & (~1));
update_id_conv.is_owned = (update_id & 1) || (update_id == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_conv);
update_id_conv = MonitorUpdateId_clone(&update_id_conv);
LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
*ret_conv = (this_arg_conv->update_persisted_channel)(this_arg_conv->this_arg, channel_id_conv, &update_conv, &data_conv, update_id_conv);
uint64_t their_features_ref = 0;
CHECK((((uint64_t)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_var);
their_features_ref = (uint64_t)their_features_var.inner;
if (their_features_var.is_owned) {
their_features_ref |= 1;
msg_var = OpenChannel_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
uint64_t their_features_ref = 0;
CHECK((((uint64_t)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_var);
their_features_ref = (uint64_t)their_features_var.inner;
if (their_features_var.is_owned) {
their_features_ref |= 1;
msg_var = AcceptChannel_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = FundingCreated_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = FundingSigned_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = FundingLocked_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
their_features_var = InitFeatures_clone(their_features);
CHECK((((uint64_t)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_var);
their_features_ref = (uint64_t)their_features_var.inner;
if (their_features_var.is_owned) {
their_features_ref |= 1;
msg_var = Shutdown_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = ClosingSigned_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = UpdateAddHTLC_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = UpdateFulfillHTLC_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = UpdateFailHTLC_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = UpdateFailMalformedHTLC_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = CommitmentSigned_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = RevokeAndACK_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = UpdateFee_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = AnnouncementSignatures_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = Init_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = ChannelReestablish_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = ChannelUpdate_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = ErrorMessage_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
LDKInitFeatures their_features_conv;
their_features_conv.inner = (void*)(their_features & (~1));
their_features_conv.is_owned = (their_features & 1) || (their_features == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_conv);
their_features_conv = InitFeatures_clone(&their_features_conv);
LDKOpenChannel msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_open_channel)(this_arg_conv->this_arg, their_node_id_ref, their_features_conv, &msg_conv);
}
LDKInitFeatures their_features_conv;
their_features_conv.inner = (void*)(their_features & (~1));
their_features_conv.is_owned = (their_features & 1) || (their_features == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_conv);
their_features_conv = InitFeatures_clone(&their_features_conv);
LDKAcceptChannel msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_accept_channel)(this_arg_conv->this_arg, their_node_id_ref, their_features_conv, &msg_conv);
}
LDKFundingCreated msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_funding_created)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKFundingSigned msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_funding_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKFundingLocked msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_funding_locked)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKInitFeatures their_features_conv;
their_features_conv.inner = (void*)(their_features & (~1));
their_features_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_conv);
LDKShutdown msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_shutdown)(this_arg_conv->this_arg, their_node_id_ref, &their_features_conv, &msg_conv);
}
LDKClosingSigned msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_closing_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKUpdateAddHTLC msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_update_add_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKUpdateFulfillHTLC msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_update_fulfill_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKUpdateFailHTLC msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_update_fail_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKUpdateFailMalformedHTLC msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_update_fail_malformed_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKCommitmentSigned msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_commitment_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKRevokeAndACK msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_revoke_and_ack)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKUpdateFee msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_update_fee)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKAnnouncementSignatures msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_announcement_signatures)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKInit msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->peer_connected)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKChannelReestablish msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_channel_reestablish)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKErrorMessage msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_error)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
msg_var = NodeAnnouncement_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_boolLightningErrorZ handle_channel_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKChannelAnnouncement * msg) {
msg_var = ChannelAnnouncement_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_boolLightningErrorZ handle_channel_update_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKChannelUpdate * msg) {
msg_var = ChannelUpdate_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcements_LDKRoutingMessageHandler_jcall(const void* this_arg, uint64_t starting_point, uint8_t batch_amount) {
void* ret_conv_59_ptr = (void*)(((uint64_t)ret_conv_59) & ~1);
CHECK_ACCESS(ret_conv_59_ptr);
LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ ret_conv_59_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ret_conv_59_ptr);
- ret_conv_59_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone((LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)ret_conv_59) & ~1));
+ FREE((void*)ret_conv_59);
ret_constr.data[h] = ret_conv_59_conv;
}
return ret_constr;
LDKNodeAnnouncement ret_conv_18_conv;
ret_conv_18_conv.inner = (void*)(ret_conv_18 & (~1));
ret_conv_18_conv.is_owned = (ret_conv_18 & 1) || (ret_conv_18 == 0);
- ret_conv_18_conv = NodeAnnouncement_clone(&ret_conv_18_conv);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_18_conv);
ret_constr.data[s] = ret_conv_18_conv;
}
return ret_constr;
init_var = Init_clone(init);
CHECK((((uint64_t)init_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&init_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(init_var);
init_ref = (uint64_t)init_var.inner;
if (init_var.is_owned) {
init_ref |= 1;
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_NoneLightningErrorZ handle_reply_short_channel_ids_end_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyShortChannelIdsEnd msg) {
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_NoneLightningErrorZ handle_query_channel_range_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryChannelRange msg) {
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_NoneLightningErrorZ handle_query_short_channel_ids_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryShortChannelIds msg) {
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
static void LDKRoutingMessageHandler_JCalls_cloned(LDKRoutingMessageHandler* new_obj) {
LDKNodeAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
*ret_conv = (this_arg_conv->handle_node_announcement)(this_arg_conv->this_arg, &msg_conv);
return (uint64_t)ret_conv;
LDKChannelAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
*ret_conv = (this_arg_conv->handle_channel_announcement)(this_arg_conv->this_arg, &msg_conv);
return (uint64_t)ret_conv;
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
*ret_conv = (this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, &msg_conv);
return (uint64_t)ret_conv;
uint64_t ret_conv_18_ref = 0;
CHECK((((uint64_t)ret_conv_18_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_18_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_18_var);
ret_conv_18_ref = (uint64_t)ret_conv_18_var.inner;
if (ret_conv_18_var.is_owned) {
ret_conv_18_ref |= 1;
LDKInit init_conv;
init_conv.inner = (void*)(init & (~1));
init_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(init_conv);
(this_arg_conv->sync_routing_table)(this_arg_conv->this_arg, their_node_id_ref, &init_conv);
}
LDKReplyChannelRange msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ReplyChannelRange_clone(&msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = (this_arg_conv->handle_reply_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
LDKReplyShortChannelIdsEnd msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ReplyShortChannelIdsEnd_clone(&msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = (this_arg_conv->handle_reply_short_channel_ids_end)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
LDKQueryChannelRange msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = QueryChannelRange_clone(&msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = (this_arg_conv->handle_query_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
LDKQueryShortChannelIds msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = QueryShortChannelIds_clone(&msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = (this_arg_conv->handle_query_short_channel_ids)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_COption_TypeZDecodeErrorZ ret_conv = *(LDKCResult_COption_TypeZDecodeErrorZ*)(ret_ptr);
- ret_conv = CResult_COption_TypeZDecodeErrorZ_clone((LDKCResult_COption_TypeZDecodeErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
static void LDKCustomMessageReader_JCalls_cloned(LDKCustomMessageReader* new_obj) {
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg_LDKCustomMessageHandler_jcall(const void* this_arg) {
void* ret_conv_25_ptr = (void*)(((uint64_t)ret_conv_25) & ~1);
CHECK_ACCESS(ret_conv_25_ptr);
LDKC2Tuple_PublicKeyTypeZ ret_conv_25_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(ret_conv_25_ptr);
- ret_conv_25_conv = C2Tuple_PublicKeyTypeZ_clone((LDKC2Tuple_PublicKeyTypeZ*)(((uint64_t)ret_conv_25) & ~1));
+ FREE((void*)ret_conv_25);
ret_constr.data[z] = ret_conv_25_conv;
}
return ret_constr;
source_var = NodeId_clone(source);
CHECK((((uint64_t)source_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&source_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(source_var);
source_ref = (uint64_t)source_var.inner;
if (source_var.is_owned) {
source_ref |= 1;
target_var = NodeId_clone(target);
CHECK((((uint64_t)target_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&target_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(target_var);
target_ref = (uint64_t)target_var.inner;
if (target_var.is_owned) {
target_ref |= 1;
uint64_t path_conv_10_ref = 0;
CHECK((((uint64_t)path_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&path_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
path_conv_10_ref = (uint64_t)path_conv_10_var.inner;
if (path_conv_10_var.is_owned) {
path_conv_10_ref |= 1;
LDKNodeId source_conv;
source_conv.inner = (void*)(source & (~1));
source_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(source_conv);
LDKNodeId target_conv;
target_conv.inner = (void*)(target & (~1));
target_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
int64_t ret_val = (this_arg_conv->channel_penalty_msat)(this_arg_conv->this_arg, short_channel_id, &source_conv, &target_conv);
return ret_val;
}
LDKRouteHop path_conv_10_conv;
path_conv_10_conv.inner = (void*)(path_conv_10 & (~1));
path_conv_10_conv.is_owned = (path_conv_10 & 1) || (path_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
path_constr.data[k] = path_conv_10_conv;
}
// Warning: we may need a move here but no clone is available for LDKChannelManager
CHECK((((uint64_t)channel_manager_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&channel_manager_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_manager_var);
channel_manager_ref = (uint64_t)channel_manager_var.inner;
if (channel_manager_var.is_owned) {
channel_manager_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneErrorZ ret_conv = *(LDKCResult_NoneErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneErrorZ_clone((LDKCResult_NoneErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
static void LDKChannelManagerPersister_JCalls_cloned(LDKChannelManagerPersister* new_obj) {
LDKChannelManager channel_manager_conv;
channel_manager_conv.inner = (void*)(channel_manager & (~1));
channel_manager_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_manager_conv);
LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
*ret_conv = (this_arg_conv->persist_manager)(this_arg_conv->this_arg, &channel_manager_conv);
return (uint64_t)ret_conv;
LDKChannelDetails ret_conv_16_conv;
ret_conv_16_conv.inner = (void*)(ret_conv_16 & (~1));
ret_conv_16_conv.is_owned = (ret_conv_16 & 1) || (ret_conv_16 == 0);
- ret_conv_16_conv = ChannelDetails_clone(&ret_conv_16_conv);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_conv);
ret_constr.data[q] = ret_conv_16_conv;
}
return ret_constr;
route_var = Route_clone(route);
CHECK((((uint64_t)route_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&route_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_var);
route_ref = (uint64_t)route_var.inner;
if (route_var.is_owned) {
route_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_PaymentIdPaymentSendFailureZ ret_conv = *(LDKCResult_PaymentIdPaymentSendFailureZ*)(ret_ptr);
- ret_conv = CResult_PaymentIdPaymentSendFailureZ_clone((LDKCResult_PaymentIdPaymentSendFailureZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_NonePaymentSendFailureZ retry_payment_LDKPayer_jcall(const void* this_arg, const LDKRoute * route, LDKThirtyTwoBytes payment_id) {
route_var = Route_clone(route);
CHECK((((uint64_t)route_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&route_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_var);
route_ref = (uint64_t)route_var.inner;
if (route_var.is_owned) {
route_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NonePaymentSendFailureZ ret_conv = *(LDKCResult_NonePaymentSendFailureZ*)(ret_ptr);
- ret_conv = CResult_NonePaymentSendFailureZ_clone((LDKCResult_NonePaymentSendFailureZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
static void LDKPayer_JCalls_cloned(LDKPayer* new_obj) {
uint64_t ret_conv_16_ref = 0;
CHECK((((uint64_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
ret_conv_16_ref = (uint64_t)ret_conv_16_var.inner;
if (ret_conv_16_var.is_owned) {
ret_conv_16_ref |= 1;
LDKRoute route_conv;
route_conv.inner = (void*)(route & (~1));
route_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
LDKThirtyTwoBytes payment_hash_ref;
CHECK(*((uint32_t*)payment_hash) == 32);
memcpy(payment_hash_ref.data, (uint8_t*)(payment_hash + 4), 32);
LDKRoute route_conv;
route_conv.inner = (void*)(route & (~1));
route_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
LDKThirtyTwoBytes payment_id_ref;
CHECK(*((uint32_t*)payment_id) == 32);
memcpy(payment_id_ref.data, (uint8_t*)(payment_id + 4), 32);
params_var = RouteParameters_clone(params);
CHECK((((uint64_t)params_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)¶ms_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(params_var);
params_ref = (uint64_t)params_var.inner;
if (params_var.is_owned) {
params_ref |= 1;
uint64_t first_hops_conv_16_ref = 0;
CHECK((((uint64_t)first_hops_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&first_hops_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_var);
first_hops_conv_16_ref = (uint64_t)first_hops_conv_16_var.inner;
if (first_hops_conv_16_var.is_owned) {
first_hops_conv_16_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_RouteLightningErrorZ ret_conv = *(LDKCResult_RouteLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_RouteLightningErrorZ_clone((LDKCResult_RouteLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
static void LDKRouter_JCalls_cloned(LDKRouter* new_obj) {
LDKRouteParameters params_conv;
params_conv.inner = (void*)(params & (~1));
params_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
LDKCVec_ChannelDetailsZ first_hops_constr;
LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL;
if (first_hops != 0) {
LDKChannelDetails first_hops_conv_16_conv;
first_hops_conv_16_conv.inner = (void*)(first_hops_conv_16 & (~1));
first_hops_conv_16_conv.is_owned = (first_hops_conv_16 & 1) || (first_hops_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_conv);
first_hops_constr.data[q] = first_hops_conv_16_conv;
}
first_hops_ptr = &first_hops_constr;
TxOut_free(_res_conv);
}
+static inline uint64_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg) {
+ LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
+ *ret_ref = TxOut_clone(arg);
+ return (uint64_t)ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_TxOut_clone_ptr(uint32_t arg) {
+ LDKTxOut* arg_conv = (LDKTxOut*)(arg & ~1);
+ int64_t ret_val = TxOut_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_TxOut_clone(uint32_t orig) {
LDKTxOut* orig_conv = (LDKTxOut*)(orig & ~1);
LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_SecretKeyErrorZ_is_ok(uint32_t o) {
+ LDKCResult_SecretKeyErrorZ* o_conv = (LDKCResult_SecretKeyErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_SecretKeyErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_SecretKeyErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_PublicKeyErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PublicKeyErrorZ* o_conv = (LDKCResult_PublicKeyErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PublicKeyErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_PublicKeyErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PublicKeyErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
+ *ret_conv = CResult_PublicKeyErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PublicKeyErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PublicKeyErrorZ* arg_conv = (LDKCResult_PublicKeyErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PublicKeyErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_PublicKeyErrorZ_clone(uint32_t orig) {
LDKCResult_PublicKeyErrorZ* orig_conv = (LDKCResult_PublicKeyErrorZ*)(orig & ~1);
LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
LDKTxCreationKeys o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = TxCreationKeys_clone(&o_conv);
LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
*ret_conv = CResult_TxCreationKeysDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
*ret_conv = CResult_TxCreationKeysDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_TxCreationKeysDecodeErrorZ* o_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_TxCreationKeysDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_TxCreationKeysDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_TxCreationKeysDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
+ *ret_conv = CResult_TxCreationKeysDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_TxCreationKeysDecodeErrorZ* arg_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_TxCreationKeysDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_TxCreationKeysDecodeErrorZ* orig_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)(orig & ~1);
LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
LDKChannelPublicKeys o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelPublicKeys_clone(&o_conv);
LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
*ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
*ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelPublicKeysDecodeErrorZ* o_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelPublicKeysDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
+ *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ChannelPublicKeysDecodeErrorZ* arg_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ChannelPublicKeysDecodeErrorZ* orig_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
LDKTxCreationKeys o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = TxCreationKeys_clone(&o_conv);
LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
*ret_conv = CResult_TxCreationKeysErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_TxCreationKeysErrorZ_is_ok(uint32_t o) {
+ LDKCResult_TxCreationKeysErrorZ* o_conv = (LDKCResult_TxCreationKeysErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_TxCreationKeysErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_TxCreationKeysErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_TxCreationKeysErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_TxCreationKeysErrorZ_clone_ptr(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR arg) {
+ LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
+ *ret_conv = CResult_TxCreationKeysErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_TxCreationKeysErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_TxCreationKeysErrorZ* arg_conv = (LDKCResult_TxCreationKeysErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_TxCreationKeysErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_TxCreationKeysErrorZ_clone(uint32_t orig) {
LDKCResult_TxCreationKeysErrorZ* orig_conv = (LDKCResult_TxCreationKeysErrorZ*)(orig & ~1);
LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
COption_u32Z_free(_res_conv);
}
+static inline uint64_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg) {
+ LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
+ *ret_copy = COption_u32Z_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_u32Z_clone_ptr(uint32_t arg) {
+ LDKCOption_u32Z* arg_conv = (LDKCOption_u32Z*)arg;
+ int64_t ret_val = COption_u32Z_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_COption_u32Z_clone(uint32_t orig) {
LDKCOption_u32Z* orig_conv = (LDKCOption_u32Z*)orig;
LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
LDKHTLCOutputInCommitment o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = HTLCOutputInCommitment_clone(&o_conv);
LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
*ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
*ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* o_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
+ *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* arg_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* orig_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(orig & ~1);
LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
LDKCounterpartyChannelTransactionParameters o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = CounterpartyChannelTransactionParameters_clone(&o_conv);
LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
*ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
*ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* o_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
+ *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* arg_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(orig & ~1);
LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
LDKChannelTransactionParameters o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelTransactionParameters_clone(&o_conv);
LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
*ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
*ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelTransactionParametersDecodeErrorZ* o_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelTransactionParametersDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
+ *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ChannelTransactionParametersDecodeErrorZ* arg_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
LDKHolderCommitmentTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = HolderCommitmentTransaction_clone(&o_conv);
LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_HolderCommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
+ *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_HolderCommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_HolderCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(orig & ~1);
LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
LDKBuiltCommitmentTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = BuiltCommitmentTransaction_clone(&o_conv);
LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
+ *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(orig & ~1);
LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
LDKTrustedClosingTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
// Warning: we need a move here but no clone is available for LDKTrustedClosingTransaction
LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
*ret_conv = CResult_TrustedClosingTransactionNoneZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_TrustedClosingTransactionNoneZ_is_ok(uint32_t o) {
+ LDKCResult_TrustedClosingTransactionNoneZ* o_conv = (LDKCResult_TrustedClosingTransactionNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_TrustedClosingTransactionNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_TrustedClosingTransactionNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKCommitmentTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = CommitmentTransaction_clone(&o_conv);
LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_CommitmentTransactionDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_CommitmentTransactionDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_CommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CommitmentTransactionDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_CommitmentTransactionDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CommitmentTransactionDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
+ *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_CommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_CommitmentTransactionDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_CommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(orig & ~1);
LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
LDKTrustedCommitmentTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
// Warning: we need a move here but no clone is available for LDKTrustedCommitmentTransaction
LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
*ret_conv = CResult_TrustedCommitmentTransactionNoneZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(uint32_t o) {
+ LDKCResult_TrustedCommitmentTransactionNoneZ* o_conv = (LDKCResult_TrustedCommitmentTransactionNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_TrustedCommitmentTransactionNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_TrustedCommitmentTransactionNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_CVec_SignatureZNoneZ_is_ok(uint32_t o) {
+ LDKCResult_CVec_SignatureZNoneZ* o_conv = (LDKCResult_CVec_SignatureZNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_CVec_SignatureZNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_CVec_SignatureZNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CVec_SignatureZNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg) {
+ LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
+ *ret_conv = CResult_CVec_SignatureZNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_CVec_SignatureZNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_CVec_SignatureZNoneZ* arg_conv = (LDKCResult_CVec_SignatureZNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_CVec_SignatureZNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_SignatureZNoneZ_clone(uint32_t orig) {
LDKCResult_CVec_SignatureZNoneZ* orig_conv = (LDKCResult_CVec_SignatureZNoneZ*)(orig & ~1);
LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
LDKShutdownScript o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ShutdownScript_clone(&o_conv);
LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
*ret_conv = CResult_ShutdownScriptDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
*ret_conv = CResult_ShutdownScriptDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ShutdownScriptDecodeErrorZ* o_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ShutdownScriptDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ShutdownScriptDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ShutdownScriptDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
+ *ret_conv = CResult_ShutdownScriptDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ShutdownScriptDecodeErrorZ* arg_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ShutdownScriptDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ShutdownScriptDecodeErrorZ* orig_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)(orig & ~1);
LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
LDKShutdownScript o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ShutdownScript_clone(&o_conv);
LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
*ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o_conv);
LDKInvalidShutdownScript e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = InvalidShutdownScript_clone(&e_conv);
LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
*ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(uint32_t o) {
+ LDKCResult_ShutdownScriptInvalidShutdownScriptZ* o_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(o & ~1);
+ jboolean ret_val = CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res_conv);
}
+static inline uint64_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg) {
+ LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
+ *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ShutdownScriptInvalidShutdownScriptZ* arg_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(arg & ~1);
+ int64_t ret_val = CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(uint32_t orig) {
LDKCResult_ShutdownScriptInvalidShutdownScriptZ* orig_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(orig & ~1);
LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NoneErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NoneErrorZ* o_conv = (LDKCResult_NoneErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NoneErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
+ *ret_conv = CResult_NoneErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NoneErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NoneErrorZ* arg_conv = (LDKCResult_NoneErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NoneErrorZ_clone(uint32_t orig) {
LDKCResult_NoneErrorZ* orig_conv = (LDKCResult_NoneErrorZ*)(orig & ~1);
LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
LDKRouteHop o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RouteHop_clone(&o_conv);
LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
*ret_conv = CResult_RouteHopDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
*ret_conv = CResult_RouteHopDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_RouteHopDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_RouteHopDecodeErrorZ* o_conv = (LDKCResult_RouteHopDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteHopDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_RouteHopDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RouteHopDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
+ *ret_conv = CResult_RouteHopDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_RouteHopDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_RouteHopDecodeErrorZ* arg_conv = (LDKCResult_RouteHopDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteHopDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_RouteHopDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_RouteHopDecodeErrorZ* orig_conv = (LDKCResult_RouteHopDecodeErrorZ*)(orig & ~1);
LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
LDKRouteHop _res_conv_10_conv;
_res_conv_10_conv.inner = (void*)(_res_conv_10 & (~1));
_res_conv_10_conv.is_owned = (_res_conv_10 & 1) || (_res_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_10_conv);
_res_constr.data[k] = _res_conv_10_conv;
}
CVec_RouteHopZ_free(_res_constr);
LDKRouteHop _res_conv_12_conv_10_conv;
_res_conv_12_conv_10_conv.inner = (void*)(_res_conv_12_conv_10 & (~1));
_res_conv_12_conv_10_conv.is_owned = (_res_conv_12_conv_10 & 1) || (_res_conv_12_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_12_conv_10_conv);
_res_conv_12_constr.data[k] = _res_conv_12_conv_10_conv;
}
_res_constr.data[m] = _res_conv_12_constr;
LDKRoute o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Route_clone(&o_conv);
LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
*ret_conv = CResult_RouteDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
*ret_conv = CResult_RouteDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_RouteDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_RouteDecodeErrorZ* o_conv = (LDKCResult_RouteDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_RouteDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RouteDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
+ *ret_conv = CResult_RouteDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_RouteDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_RouteDecodeErrorZ* arg_conv = (LDKCResult_RouteDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_RouteDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_RouteDecodeErrorZ* orig_conv = (LDKCResult_RouteDecodeErrorZ*)(orig & ~1);
LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
LDKRouteParameters o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RouteParameters_clone(&o_conv);
LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
*ret_conv = CResult_RouteParametersDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
*ret_conv = CResult_RouteParametersDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_RouteParametersDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_RouteParametersDecodeErrorZ* o_conv = (LDKCResult_RouteParametersDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteParametersDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_RouteParametersDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RouteParametersDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
+ *ret_conv = CResult_RouteParametersDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_RouteParametersDecodeErrorZ* arg_conv = (LDKCResult_RouteParametersDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteParametersDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_RouteParametersDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_RouteParametersDecodeErrorZ* orig_conv = (LDKCResult_RouteParametersDecodeErrorZ*)(orig & ~1);
LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
LDKRouteHint _res_conv_11_conv;
_res_conv_11_conv.inner = (void*)(_res_conv_11 & (~1));
_res_conv_11_conv.is_owned = (_res_conv_11 & 1) || (_res_conv_11 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_11_conv);
_res_constr.data[l] = _res_conv_11_conv;
}
CVec_RouteHintZ_free(_res_constr);
COption_u64Z_free(_res_conv);
}
+static inline uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg) {
+ LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
+ *ret_copy = COption_u64Z_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_u64Z_clone_ptr(uint32_t arg) {
+ LDKCOption_u64Z* arg_conv = (LDKCOption_u64Z*)arg;
+ int64_t ret_val = COption_u64Z_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_COption_u64Z_clone(uint32_t orig) {
LDKCOption_u64Z* orig_conv = (LDKCOption_u64Z*)orig;
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
LDKPayee o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Payee_clone(&o_conv);
LDKCResult_PayeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeeDecodeErrorZ), "LDKCResult_PayeeDecodeErrorZ");
*ret_conv = CResult_PayeeDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_PayeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeeDecodeErrorZ), "LDKCResult_PayeeDecodeErrorZ");
*ret_conv = CResult_PayeeDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_PayeeDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PayeeDecodeErrorZ* o_conv = (LDKCResult_PayeeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PayeeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_PayeeDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PayeeDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PayeeDecodeErrorZ_clone_ptr(LDKCResult_PayeeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PayeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeeDecodeErrorZ), "LDKCResult_PayeeDecodeErrorZ");
+ *ret_conv = CResult_PayeeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PayeeDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PayeeDecodeErrorZ* arg_conv = (LDKCResult_PayeeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PayeeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_PayeeDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_PayeeDecodeErrorZ* orig_conv = (LDKCResult_PayeeDecodeErrorZ*)(orig & ~1);
LDKCResult_PayeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeeDecodeErrorZ), "LDKCResult_PayeeDecodeErrorZ");
LDKRouteHintHop _res_conv_14_conv;
_res_conv_14_conv.inner = (void*)(_res_conv_14 & (~1));
_res_conv_14_conv.is_owned = (_res_conv_14 & 1) || (_res_conv_14 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_14_conv);
_res_constr.data[o] = _res_conv_14_conv;
}
CVec_RouteHintHopZ_free(_res_constr);
LDKRouteHint o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RouteHint_clone(&o_conv);
LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
*ret_conv = CResult_RouteHintDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
*ret_conv = CResult_RouteHintDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_RouteHintDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_RouteHintDecodeErrorZ* o_conv = (LDKCResult_RouteHintDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteHintDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_RouteHintDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RouteHintDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
+ *ret_conv = CResult_RouteHintDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_RouteHintDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_RouteHintDecodeErrorZ* arg_conv = (LDKCResult_RouteHintDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteHintDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_RouteHintDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_RouteHintDecodeErrorZ* orig_conv = (LDKCResult_RouteHintDecodeErrorZ*)(orig & ~1);
LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
LDKRouteHintHop o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RouteHintHop_clone(&o_conv);
LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
*ret_conv = CResult_RouteHintHopDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
*ret_conv = CResult_RouteHintHopDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_RouteHintHopDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_RouteHintHopDecodeErrorZ* o_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteHintHopDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_RouteHintHopDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RouteHintHopDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
+ *ret_conv = CResult_RouteHintHopDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_RouteHintHopDecodeErrorZ* arg_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_RouteHintHopDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_RouteHintHopDecodeErrorZ* orig_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)(orig & ~1);
LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
LDKChannelDetails _res_conv_16_conv;
_res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
_res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
_res_constr.data[q] = _res_conv_16_conv;
}
CVec_ChannelDetailsZ_free(_res_constr);
LDKRoute o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Route_clone(&o_conv);
LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
*ret_conv = CResult_RouteLightningErrorZ_ok(o_conv);
LDKLightningError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = LightningError_clone(&e_conv);
LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
*ret_conv = CResult_RouteLightningErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
-void __attribute__((visibility("default"))) TS_CResult_RouteLightningErrorZ_free(uint32_t _res) {
- if ((_res & 1) != 0) return;
+jboolean __attribute__((visibility("default"))) TS_CResult_RouteLightningErrorZ_is_ok(uint32_t o) {
+ LDKCResult_RouteLightningErrorZ* o_conv = (LDKCResult_RouteLightningErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteLightningErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_RouteLightningErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CHECK_ACCESS(_res_ptr);
LDKCResult_RouteLightningErrorZ _res_conv = *(LDKCResult_RouteLightningErrorZ*)(_res_ptr);
CResult_RouteLightningErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
+ *ret_conv = CResult_RouteLightningErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_RouteLightningErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_RouteLightningErrorZ* arg_conv = (LDKCResult_RouteLightningErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteLightningErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_RouteLightningErrorZ_clone(uint32_t orig) {
LDKCResult_RouteLightningErrorZ* orig_conv = (LDKCResult_RouteLightningErrorZ*)(orig & ~1);
LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_TxOutAccessErrorZ_is_ok(uint32_t o) {
+ LDKCResult_TxOutAccessErrorZ* o_conv = (LDKCResult_TxOutAccessErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_TxOutAccessErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_TxOutAccessErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_TxOutAccessErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg) {
+ LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
+ *ret_conv = CResult_TxOutAccessErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_TxOutAccessErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_TxOutAccessErrorZ* arg_conv = (LDKCResult_TxOutAccessErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_TxOutAccessErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_TxOutAccessErrorZ_clone(uint32_t orig) {
LDKCResult_TxOutAccessErrorZ* orig_conv = (LDKCResult_TxOutAccessErrorZ*)(orig & ~1);
LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg) {
+ LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
+ *ret_conv = C2Tuple_usizeTransactionZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_usizeTransactionZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_usizeTransactionZ* arg_conv = (LDKC2Tuple_usizeTransactionZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_usizeTransactionZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C2Tuple_usizeTransactionZ_clone(uint32_t orig) {
LDKC2Tuple_usizeTransactionZ* orig_conv = (LDKC2Tuple_usizeTransactionZ*)(orig & ~1);
LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NoneChannelMonitorUpdateErrZ_is_ok(uint32_t o) {
+ LDKCResult_NoneChannelMonitorUpdateErrZ* o_conv = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneChannelMonitorUpdateErrZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NoneChannelMonitorUpdateErrZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneChannelMonitorUpdateErrZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR arg) {
+ LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
+ *ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NoneChannelMonitorUpdateErrZ* arg_conv = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NoneChannelMonitorUpdateErrZ_clone(uint32_t orig) {
LDKCResult_NoneChannelMonitorUpdateErrZ* orig_conv = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(orig & ~1);
LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
COption_C2Tuple_usizeTransactionZZ_free(_res_conv);
}
+static inline uint64_t COption_C2Tuple_usizeTransactionZZ_clone_ptr(LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR arg) {
+ LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
+ *ret_copy = COption_C2Tuple_usizeTransactionZZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_C2Tuple_usizeTransactionZZ_clone_ptr(uint32_t arg) {
+ LDKCOption_C2Tuple_usizeTransactionZZ* arg_conv = (LDKCOption_C2Tuple_usizeTransactionZZ*)arg;
+ int64_t ret_val = COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_COption_C2Tuple_usizeTransactionZZ_clone(uint32_t orig) {
LDKCOption_C2Tuple_usizeTransactionZZ* orig_conv = (LDKCOption_C2Tuple_usizeTransactionZZ*)orig;
LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
return ret_ref;
}
+uint32_t __attribute__((visibility("default"))) TS_COption_ClosureReasonZ_some(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKClosureReason o_conv = *(LDKClosureReason*)(o_ptr);
+ o_conv = ClosureReason_clone((LDKClosureReason*)(((uint64_t)o) & ~1));
+ LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
+ *ret_copy = COption_ClosureReasonZ_some(o_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_ClosureReasonZ_none() {
+ LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
+ *ret_copy = COption_ClosureReasonZ_none();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_COption_ClosureReasonZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_ClosureReasonZ _res_conv = *(LDKCOption_ClosureReasonZ*)(_res_ptr);
+ FREE((void*)_res);
+ COption_ClosureReasonZ_free(_res_conv);
+}
+
+static inline uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg) {
+ LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
+ *ret_copy = COption_ClosureReasonZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_ClosureReasonZ_clone_ptr(uint32_t arg) {
+ LDKCOption_ClosureReasonZ* arg_conv = (LDKCOption_ClosureReasonZ*)arg;
+ int64_t ret_val = COption_ClosureReasonZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_ClosureReasonZ_clone(uint32_t orig) {
+ LDKCOption_ClosureReasonZ* orig_conv = (LDKCOption_ClosureReasonZ*)orig;
+ LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
+ *ret_copy = COption_ClosureReasonZ_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKCOption_ClosureReasonZ o_conv = *(LDKCOption_ClosureReasonZ*)(o_ptr);
+ o_conv = COption_ClosureReasonZ_clone((LDKCOption_ClosureReasonZ*)(((uint64_t)o) & ~1));
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* o_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ _res_conv = *(LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_COption_ClosureReasonZDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* arg_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* orig_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(orig & ~1);
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
uint32_t __attribute__((visibility("default"))) TS_COption_NetworkUpdateZ_some(uint32_t o) {
void* o_ptr = (void*)(((uint64_t)o) & ~1);
CHECK_ACCESS(o_ptr);
COption_NetworkUpdateZ_free(_res_conv);
}
+static inline uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg) {
+ LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
+ *ret_copy = COption_NetworkUpdateZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_NetworkUpdateZ_clone_ptr(uint32_t arg) {
+ LDKCOption_NetworkUpdateZ* arg_conv = (LDKCOption_NetworkUpdateZ*)arg;
+ int64_t ret_val = COption_NetworkUpdateZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_COption_NetworkUpdateZ_clone(uint32_t orig) {
LDKCOption_NetworkUpdateZ* orig_conv = (LDKCOption_NetworkUpdateZ*)orig;
LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
CVec_SpendableOutputDescriptorZ_free(_res_constr);
}
+uint32_t __attribute__((visibility("default"))) TS_COption_EventZ_some(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKEvent o_conv = *(LDKEvent*)(o_ptr);
+ o_conv = Event_clone((LDKEvent*)(((uint64_t)o) & ~1));
+ LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
+ *ret_copy = COption_EventZ_some(o_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_EventZ_none() {
+ LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
+ *ret_copy = COption_EventZ_none();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_COption_EventZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_EventZ _res_conv = *(LDKCOption_EventZ*)(_res_ptr);
+ FREE((void*)_res);
+ COption_EventZ_free(_res_conv);
+}
+
+static inline uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg) {
+ LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
+ *ret_copy = COption_EventZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_EventZ_clone_ptr(uint32_t arg) {
+ LDKCOption_EventZ* arg_conv = (LDKCOption_EventZ*)arg;
+ int64_t ret_val = COption_EventZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_EventZ_clone(uint32_t orig) {
+ LDKCOption_EventZ* orig_conv = (LDKCOption_EventZ*)orig;
+ LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
+ *ret_copy = COption_EventZ_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_EventZDecodeErrorZ_ok(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKCOption_EventZ o_conv = *(LDKCOption_EventZ*)(o_ptr);
+ o_conv = COption_EventZ_clone((LDKCOption_EventZ*)(((uint64_t)o) & ~1));
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = CResult_COption_EventZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_EventZDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = CResult_COption_EventZDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_COption_EventZDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_COption_EventZDecodeErrorZ* o_conv = (LDKCResult_COption_EventZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_EventZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_COption_EventZDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_COption_EventZDecodeErrorZ _res_conv = *(LDKCResult_COption_EventZDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_COption_EventZDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = CResult_COption_EventZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_COption_EventZDecodeErrorZ* arg_conv = (LDKCResult_COption_EventZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_EventZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_EventZDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_COption_EventZDecodeErrorZ* orig_conv = (LDKCResult_COption_EventZDecodeErrorZ*)(orig & ~1);
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = CResult_COption_EventZDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
void __attribute__((visibility("default"))) TS_CVec_MessageSendEventZ_free(uint32_tArray _res) {
LDKCVec_MessageSendEventZ _res_constr;
_res_constr.datalen = *((uint32_t*)_res);
LDKInitFeatures o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = InitFeatures_clone(&o_conv);
LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
*ret_conv = CResult_InitFeaturesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
*ret_conv = CResult_InitFeaturesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_InitFeaturesDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_InitFeaturesDecodeErrorZ* o_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InitFeaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_InitFeaturesDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKNodeFeatures o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NodeFeatures_clone(&o_conv);
LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
*ret_conv = CResult_NodeFeaturesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
*ret_conv = CResult_NodeFeaturesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NodeFeaturesDecodeErrorZ* o_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeFeaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NodeFeaturesDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKChannelFeatures o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelFeatures_clone(&o_conv);
LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
*ret_conv = CResult_ChannelFeaturesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
*ret_conv = CResult_ChannelFeaturesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelFeaturesDecodeErrorZ* o_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelFeaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ChannelFeaturesDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKInvoiceFeatures o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = InvoiceFeatures_clone(&o_conv);
LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
*ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
*ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_InvoiceFeaturesDecodeErrorZ* o_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKScoringParameters o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
// Warning: we need a move here but no clone is available for LDKScoringParameters
LDKCResult_ScoringParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ScoringParametersDecodeErrorZ), "LDKCResult_ScoringParametersDecodeErrorZ");
*ret_conv = CResult_ScoringParametersDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ScoringParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ScoringParametersDecodeErrorZ), "LDKCResult_ScoringParametersDecodeErrorZ");
*ret_conv = CResult_ScoringParametersDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ScoringParametersDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ScoringParametersDecodeErrorZ* o_conv = (LDKCResult_ScoringParametersDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ScoringParametersDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ScoringParametersDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKScorer o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
// Warning: we need a move here but no clone is available for LDKScorer
LDKCResult_ScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ScorerDecodeErrorZ), "LDKCResult_ScorerDecodeErrorZ");
*ret_conv = CResult_ScorerDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ScorerDecodeErrorZ), "LDKCResult_ScorerDecodeErrorZ");
*ret_conv = CResult_ScorerDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ScorerDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ScorerDecodeErrorZ* o_conv = (LDKCResult_ScorerDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ScorerDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ScorerDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKDelayedPaymentOutputDescriptor o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = DelayedPaymentOutputDescriptor_clone(&o_conv);
LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
*ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
*ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(orig & ~1);
LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
LDKStaticPaymentOutputDescriptor o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = StaticPaymentOutputDescriptor_clone(&o_conv);
LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
*ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
*ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(orig & ~1);
LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
*ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_SpendableOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(orig & ~1);
LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NoneNoneZ_is_ok(uint32_t o) {
+ LDKCResult_NoneNoneZ* o_conv = (LDKCResult_NoneNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NoneNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg) {
+ LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
+ *ret_conv = CResult_NoneNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NoneNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NoneNoneZ* arg_conv = (LDKCResult_NoneNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NoneNoneZ_clone(uint32_t orig) {
LDKCResult_NoneNoneZ* orig_conv = (LDKCResult_NoneNoneZ*)(orig & ~1);
LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg) {
+ LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
+ *ret_conv = C2Tuple_SignatureCVec_SignatureZZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_SignatureCVec_SignatureZZ* arg_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C2Tuple_SignatureCVec_SignatureZZ_clone(uint32_t orig) {
LDKC2Tuple_SignatureCVec_SignatureZZ* orig_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(orig & ~1);
LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(uint32_t o) {
+ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* o_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg) {
+ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
+ *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* arg_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(uint32_t orig) {
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* orig_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(orig & ~1);
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_SignatureNoneZ_is_ok(uint32_t o) {
+ LDKCResult_SignatureNoneZ* o_conv = (LDKCResult_SignatureNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_SignatureNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_SignatureNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_SignatureNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg) {
+ LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
+ *ret_conv = CResult_SignatureNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_SignatureNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_SignatureNoneZ* arg_conv = (LDKCResult_SignatureNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_SignatureNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_SignatureNoneZ_clone(uint32_t orig) {
LDKCResult_SignatureNoneZ* orig_conv = (LDKCResult_SignatureNoneZ*)(orig & ~1);
LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
*ret_conv = CResult_SignDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_SignDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_SignDecodeErrorZ* o_conv = (LDKCResult_SignDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_SignDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_SignDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_SignDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
+ *ret_conv = CResult_SignDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_SignDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_SignDecodeErrorZ* arg_conv = (LDKCResult_SignDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_SignDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_SignDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_SignDecodeErrorZ* orig_conv = (LDKCResult_SignDecodeErrorZ*)(orig & ~1);
LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_RecoverableSignatureNoneZ_is_ok(uint32_t o) {
+ LDKCResult_RecoverableSignatureNoneZ* o_conv = (LDKCResult_RecoverableSignatureNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_RecoverableSignatureNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_RecoverableSignatureNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RecoverableSignatureNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg) {
+ LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
+ *ret_conv = CResult_RecoverableSignatureNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_RecoverableSignatureNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_RecoverableSignatureNoneZ* arg_conv = (LDKCResult_RecoverableSignatureNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_RecoverableSignatureNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_RecoverableSignatureNoneZ_clone(uint32_t orig) {
LDKCResult_RecoverableSignatureNoneZ* orig_conv = (LDKCResult_RecoverableSignatureNoneZ*)(orig & ~1);
LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(uint32_t o) {
+ LDKCResult_CVec_CVec_u8ZZNoneZ* o_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_CVec_CVec_u8ZZNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_CVec_CVec_u8ZZNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CVec_CVec_u8ZZNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg) {
+ LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
+ *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_CVec_CVec_u8ZZNoneZ* arg_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_CVec_u8ZZNoneZ_clone(uint32_t orig) {
LDKCResult_CVec_CVec_u8ZZNoneZ* orig_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(orig & ~1);
LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
LDKInMemorySigner o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = InMemorySigner_clone(&o_conv);
LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
*ret_conv = CResult_InMemorySignerDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
*ret_conv = CResult_InMemorySignerDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_InMemorySignerDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_InMemorySignerDecodeErrorZ* o_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InMemorySignerDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_InMemorySignerDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_InMemorySignerDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
+ *ret_conv = CResult_InMemorySignerDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_InMemorySignerDecodeErrorZ* arg_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_InMemorySignerDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_InMemorySignerDecodeErrorZ* orig_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(orig & ~1);
LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_TransactionNoneZ_is_ok(uint32_t o) {
+ LDKCResult_TransactionNoneZ* o_conv = (LDKCResult_TransactionNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_TransactionNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_TransactionNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_TransactionNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg) {
+ LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
+ *ret_conv = CResult_TransactionNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_TransactionNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_TransactionNoneZ* arg_conv = (LDKCResult_TransactionNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_TransactionNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_TransactionNoneZ_clone(uint32_t orig) {
LDKCResult_TransactionNoneZ* orig_conv = (LDKCResult_TransactionNoneZ*)(orig & ~1);
LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg) {
+ LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
+ *ret_conv = C2Tuple_BlockHashChannelMonitorZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_BlockHashChannelMonitorZ* arg_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelMonitorZ_clone(uint32_t orig) {
LDKC2Tuple_BlockHashChannelMonitorZ* orig_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)(orig & ~1);
LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
LDKChannelMonitor b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = (b & 1) || (b == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
b_conv = ChannelMonitor_clone(&b_conv);
LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
*ret_conv = C2Tuple_BlockHashChannelMonitorZ_new(a_ref, b_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_is_ok(uint32_t o) {
+ LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* o_conv = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone_ptr(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ), "LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ");
+ *ret_conv = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* arg_conv = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone(uint32_t orig) {
LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* orig_conv = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(orig & ~1);
LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ), "LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ");
COption_u16Z_free(_res_conv);
}
+static inline uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg) {
+ LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
+ *ret_copy = COption_u16Z_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_u16Z_clone_ptr(uint32_t arg) {
+ LDKCOption_u16Z* arg_conv = (LDKCOption_u16Z*)arg;
+ int64_t ret_val = COption_u16Z_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_COption_u16Z_clone(uint32_t orig) {
LDKCOption_u16Z* orig_conv = (LDKCOption_u16Z*)orig;
LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NoneAPIErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NoneAPIErrorZ* o_conv = (LDKCResult_NoneAPIErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneAPIErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NoneAPIErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneAPIErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
+ *ret_conv = CResult_NoneAPIErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NoneAPIErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NoneAPIErrorZ* arg_conv = (LDKCResult_NoneAPIErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneAPIErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NoneAPIErrorZ_clone(uint32_t orig) {
LDKCResult_NoneAPIErrorZ* orig_conv = (LDKCResult_NoneAPIErrorZ*)(orig & ~1);
LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult__u832APIErrorZ_is_ok(uint32_t o) {
+ LDKCResult__u832APIErrorZ* o_conv = (LDKCResult__u832APIErrorZ*)(o & ~1);
+ jboolean ret_val = CResult__u832APIErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult__u832APIErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult__u832APIErrorZ_free(_res_conv);
}
+static inline uint64_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg) {
+ LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
+ *ret_conv = CResult__u832APIErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult__u832APIErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult__u832APIErrorZ* arg_conv = (LDKCResult__u832APIErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult__u832APIErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult__u832APIErrorZ_clone(uint32_t orig) {
LDKCResult__u832APIErrorZ* orig_conv = (LDKCResult__u832APIErrorZ*)(orig & ~1);
LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentSendFailureZ_is_ok(uint32_t o) {
+ LDKCResult_PaymentIdPaymentSendFailureZ* o_conv = (LDKCResult_PaymentIdPaymentSendFailureZ*)(o & ~1);
+ jboolean ret_val = CResult_PaymentIdPaymentSendFailureZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentSendFailureZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PaymentIdPaymentSendFailureZ_free(_res_conv);
}
+static inline uint64_t CResult_PaymentIdPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR arg) {
+ LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ");
+ *ret_conv = CResult_PaymentIdPaymentSendFailureZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentSendFailureZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PaymentIdPaymentSendFailureZ* arg_conv = (LDKCResult_PaymentIdPaymentSendFailureZ*)(arg & ~1);
+ int64_t ret_val = CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentSendFailureZ_clone(uint32_t orig) {
LDKCResult_PaymentIdPaymentSendFailureZ* orig_conv = (LDKCResult_PaymentIdPaymentSendFailureZ*)(orig & ~1);
LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_is_ok(uint32_t o) {
+ LDKCResult_NonePaymentSendFailureZ* o_conv = (LDKCResult_NonePaymentSendFailureZ*)(o & ~1);
+ jboolean ret_val = CResult_NonePaymentSendFailureZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NonePaymentSendFailureZ_free(_res_conv);
}
+static inline uint64_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg) {
+ LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
+ *ret_conv = CResult_NonePaymentSendFailureZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NonePaymentSendFailureZ* arg_conv = (LDKCResult_NonePaymentSendFailureZ*)(arg & ~1);
+ int64_t ret_val = CResult_NonePaymentSendFailureZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_clone(uint32_t orig) {
LDKCResult_NonePaymentSendFailureZ* orig_conv = (LDKCResult_NonePaymentSendFailureZ*)(orig & ~1);
LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg) {
+ LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
+ *ret_conv = C2Tuple_PaymentHashPaymentIdZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_PaymentHashPaymentIdZ* arg_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentIdZ_clone(uint32_t orig) {
LDKC2Tuple_PaymentHashPaymentIdZ* orig_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)(orig & ~1);
LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(uint32_t o) {
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* o_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(o & ~1);
+ jboolean ret_val = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res_conv);
}
+static inline uint64_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg) {
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
+ *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(uint32_t arg) {
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* arg_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(arg & ~1);
+ int64_t ret_val = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(uint32_t orig) {
LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* orig_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(orig & ~1);
LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
CVec_NetAddressZ_free(_res_constr);
}
+static inline uint64_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg) {
+ LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
+ *ret_conv = C2Tuple_PaymentHashPaymentSecretZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_PaymentHashPaymentSecretZ* arg_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentSecretZ_clone(uint32_t orig) {
LDKC2Tuple_PaymentHashPaymentSecretZ* orig_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(orig & ~1);
LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_PaymentSecretAPIErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PaymentSecretAPIErrorZ* o_conv = (LDKCResult_PaymentSecretAPIErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PaymentSecretAPIErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_PaymentSecretAPIErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PaymentSecretAPIErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
+ *ret_conv = CResult_PaymentSecretAPIErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PaymentSecretAPIErrorZ* arg_conv = (LDKCResult_PaymentSecretAPIErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PaymentSecretAPIErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentSecretAPIErrorZ_clone(uint32_t orig) {
LDKCResult_PaymentSecretAPIErrorZ* orig_conv = (LDKCResult_PaymentSecretAPIErrorZ*)(orig & ~1);
LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
LDKChannelMonitor _res_conv_16_conv;
_res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
_res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
_res_constr.data[q] = _res_conv_16_conv;
}
CVec_ChannelMonitorZ_free(_res_constr);
LDKChannelManager b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = (b & 1) || (b == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
// Warning: we need a move here but no clone is available for LDKChannelManager
LDKC2Tuple_BlockHashChannelManagerZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelManagerZ), "LDKC2Tuple_BlockHashChannelManagerZ");
*ret_conv = C2Tuple_BlockHashChannelManagerZ_new(a_ref, b_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
*ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* o_conv = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKChannelConfig o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelConfig_clone(&o_conv);
LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
*ret_conv = CResult_ChannelConfigDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
*ret_conv = CResult_ChannelConfigDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelConfigDecodeErrorZ* o_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelConfigDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelConfigDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
+ *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ChannelConfigDecodeErrorZ* arg_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ChannelConfigDecodeErrorZ* orig_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
LDKOutPoint o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = OutPoint_clone(&o_conv);
LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
*ret_conv = CResult_OutPointDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
*ret_conv = CResult_OutPointDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_OutPointDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_OutPointDecodeErrorZ* o_conv = (LDKCResult_OutPointDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_OutPointDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_OutPointDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_OutPointDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
+ *ret_conv = CResult_OutPointDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_OutPointDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_OutPointDecodeErrorZ* arg_conv = (LDKCResult_OutPointDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_OutPointDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_OutPointDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_OutPointDecodeErrorZ* orig_conv = (LDKCResult_OutPointDecodeErrorZ*)(orig & ~1);
LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
COption_TypeZ_free(_res_conv);
}
+static inline uint64_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg) {
+ LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
+ *ret_copy = COption_TypeZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_TypeZ_clone_ptr(uint32_t arg) {
+ LDKCOption_TypeZ* arg_conv = (LDKCOption_TypeZ*)arg;
+ int64_t ret_val = COption_TypeZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_COption_TypeZ_clone(uint32_t orig) {
LDKCOption_TypeZ* orig_conv = (LDKCOption_TypeZ*)orig;
LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
*ret_conv = CResult_COption_TypeZDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_COption_TypeZDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_COption_TypeZDecodeErrorZ* o_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_TypeZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_COption_TypeZDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_COption_TypeZDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
+ *ret_conv = CResult_COption_TypeZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_COption_TypeZDecodeErrorZ* arg_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_COption_TypeZDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_COption_TypeZDecodeErrorZ* orig_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)(orig & ~1);
LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PaymentIdPaymentErrorZ* o_conv = (LDKCResult_PaymentIdPaymentErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PaymentIdPaymentErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PaymentIdPaymentErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
+ *ret_conv = CResult_PaymentIdPaymentErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PaymentIdPaymentErrorZ* arg_conv = (LDKCResult_PaymentIdPaymentErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PaymentIdPaymentErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentErrorZ_clone(uint32_t orig) {
LDKCResult_PaymentIdPaymentErrorZ* orig_conv = (LDKCResult_PaymentIdPaymentErrorZ*)(orig & ~1);
LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_SiPrefixNoneZ_is_ok(uint32_t o) {
+ LDKCResult_SiPrefixNoneZ* o_conv = (LDKCResult_SiPrefixNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_SiPrefixNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_SiPrefixNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_SiPrefixNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_SiPrefixNoneZ_clone_ptr(LDKCResult_SiPrefixNoneZ *NONNULL_PTR arg) {
+ LDKCResult_SiPrefixNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixNoneZ), "LDKCResult_SiPrefixNoneZ");
+ *ret_conv = CResult_SiPrefixNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_SiPrefixNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_SiPrefixNoneZ* arg_conv = (LDKCResult_SiPrefixNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_SiPrefixNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_SiPrefixNoneZ_clone(uint32_t orig) {
LDKCResult_SiPrefixNoneZ* orig_conv = (LDKCResult_SiPrefixNoneZ*)(orig & ~1);
LDKCResult_SiPrefixNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixNoneZ), "LDKCResult_SiPrefixNoneZ");
LDKInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Invoice_clone(&o_conv);
LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
*ret_conv = CResult_InvoiceNoneZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_InvoiceNoneZ_is_ok(uint32_t o) {
+ LDKCResult_InvoiceNoneZ* o_conv = (LDKCResult_InvoiceNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_InvoiceNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_InvoiceNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_InvoiceNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_InvoiceNoneZ_clone_ptr(LDKCResult_InvoiceNoneZ *NONNULL_PTR arg) {
+ LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
+ *ret_conv = CResult_InvoiceNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_InvoiceNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_InvoiceNoneZ* arg_conv = (LDKCResult_InvoiceNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_InvoiceNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceNoneZ_clone(uint32_t orig) {
LDKCResult_InvoiceNoneZ* orig_conv = (LDKCResult_InvoiceNoneZ*)(orig & ~1);
LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
LDKSignedRawInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = SignedRawInvoice_clone(&o_conv);
LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
*ret_conv = CResult_SignedRawInvoiceNoneZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_SignedRawInvoiceNoneZ_is_ok(uint32_t o) {
+ LDKCResult_SignedRawInvoiceNoneZ* o_conv = (LDKCResult_SignedRawInvoiceNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_SignedRawInvoiceNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_SignedRawInvoiceNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_SignedRawInvoiceNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_SignedRawInvoiceNoneZ_clone_ptr(LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR arg) {
+ LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
+ *ret_conv = CResult_SignedRawInvoiceNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_SignedRawInvoiceNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_SignedRawInvoiceNoneZ* arg_conv = (LDKCResult_SignedRawInvoiceNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_SignedRawInvoiceNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_SignedRawInvoiceNoneZ_clone(uint32_t orig) {
LDKCResult_SignedRawInvoiceNoneZ* orig_conv = (LDKCResult_SignedRawInvoiceNoneZ*)(orig & ~1);
LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg) {
+ LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
+ *ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(uint32_t arg) {
+ LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* arg_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(arg & ~1);
+ int64_t ret_val = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(uint32_t orig) {
LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* orig_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(orig & ~1);
LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
LDKRawInvoice a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = RawInvoice_clone(&a_conv);
LDKThirtyTwoBytes b_ref;
CHECK(*((uint32_t*)b) == 32);
LDKInvoiceSignature c_conv;
c_conv.inner = (void*)(c & (~1));
c_conv.is_owned = (c & 1) || (c == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(c_conv);
c_conv = InvoiceSignature_clone(&c_conv);
LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
*ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a_conv, b_ref, c_conv);
LDKPayeePubKey o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = PayeePubKey_clone(&o_conv);
LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
*ret_conv = CResult_PayeePubKeyErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_PayeePubKeyErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PayeePubKeyErrorZ* o_conv = (LDKCResult_PayeePubKeyErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PayeePubKeyErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_PayeePubKeyErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PayeePubKeyErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
+ *ret_conv = CResult_PayeePubKeyErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PayeePubKeyErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PayeePubKeyErrorZ* arg_conv = (LDKCResult_PayeePubKeyErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PayeePubKeyErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_PayeePubKeyErrorZ_clone(uint32_t orig) {
LDKCResult_PayeePubKeyErrorZ* orig_conv = (LDKCResult_PayeePubKeyErrorZ*)(orig & ~1);
LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
LDKPrivateRoute _res_conv_14_conv;
_res_conv_14_conv.inner = (void*)(_res_conv_14 & (~1));
_res_conv_14_conv.is_owned = (_res_conv_14 & 1) || (_res_conv_14 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_14_conv);
_res_constr.data[o] = _res_conv_14_conv;
}
CVec_PrivateRouteZ_free(_res_constr);
LDKPositiveTimestamp o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = PositiveTimestamp_clone(&o_conv);
LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
*ret_conv = CResult_PositiveTimestampCreationErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_PositiveTimestampCreationErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PositiveTimestampCreationErrorZ* o_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PositiveTimestampCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_PositiveTimestampCreationErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PositiveTimestampCreationErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
+ *ret_conv = CResult_PositiveTimestampCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PositiveTimestampCreationErrorZ* arg_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_PositiveTimestampCreationErrorZ_clone(uint32_t orig) {
LDKCResult_PositiveTimestampCreationErrorZ* orig_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)(orig & ~1);
LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NoneSemanticErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NoneSemanticErrorZ* o_conv = (LDKCResult_NoneSemanticErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneSemanticErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NoneSemanticErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneSemanticErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
+ *ret_conv = CResult_NoneSemanticErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NoneSemanticErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NoneSemanticErrorZ* arg_conv = (LDKCResult_NoneSemanticErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneSemanticErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NoneSemanticErrorZ_clone(uint32_t orig) {
LDKCResult_NoneSemanticErrorZ* orig_conv = (LDKCResult_NoneSemanticErrorZ*)(orig & ~1);
LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
LDKInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Invoice_clone(&o_conv);
LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
*ret_conv = CResult_InvoiceSemanticErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_InvoiceSemanticErrorZ_is_ok(uint32_t o) {
+ LDKCResult_InvoiceSemanticErrorZ* o_conv = (LDKCResult_InvoiceSemanticErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InvoiceSemanticErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_InvoiceSemanticErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_InvoiceSemanticErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg) {
+ LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
+ *ret_conv = CResult_InvoiceSemanticErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_InvoiceSemanticErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_InvoiceSemanticErrorZ* arg_conv = (LDKCResult_InvoiceSemanticErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_InvoiceSemanticErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceSemanticErrorZ_clone(uint32_t orig) {
LDKCResult_InvoiceSemanticErrorZ* orig_conv = (LDKCResult_InvoiceSemanticErrorZ*)(orig & ~1);
LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
LDKDescription o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Description_clone(&o_conv);
LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
*ret_conv = CResult_DescriptionCreationErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_DescriptionCreationErrorZ_is_ok(uint32_t o) {
+ LDKCResult_DescriptionCreationErrorZ* o_conv = (LDKCResult_DescriptionCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_DescriptionCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_DescriptionCreationErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_DescriptionCreationErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
+ *ret_conv = CResult_DescriptionCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_DescriptionCreationErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_DescriptionCreationErrorZ* arg_conv = (LDKCResult_DescriptionCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_DescriptionCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_DescriptionCreationErrorZ_clone(uint32_t orig) {
LDKCResult_DescriptionCreationErrorZ* orig_conv = (LDKCResult_DescriptionCreationErrorZ*)(orig & ~1);
LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
LDKExpiryTime o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ExpiryTime_clone(&o_conv);
LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
*ret_conv = CResult_ExpiryTimeCreationErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ExpiryTimeCreationErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ExpiryTimeCreationErrorZ* o_conv = (LDKCResult_ExpiryTimeCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ExpiryTimeCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ExpiryTimeCreationErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ExpiryTimeCreationErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ExpiryTimeCreationErrorZ_clone_ptr(LDKCResult_ExpiryTimeCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
+ *ret_conv = CResult_ExpiryTimeCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ExpiryTimeCreationErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ExpiryTimeCreationErrorZ* arg_conv = (LDKCResult_ExpiryTimeCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ExpiryTimeCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ExpiryTimeCreationErrorZ_clone(uint32_t orig) {
LDKCResult_ExpiryTimeCreationErrorZ* orig_conv = (LDKCResult_ExpiryTimeCreationErrorZ*)(orig & ~1);
LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
LDKPrivateRoute o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = PrivateRoute_clone(&o_conv);
LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
*ret_conv = CResult_PrivateRouteCreationErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_PrivateRouteCreationErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PrivateRouteCreationErrorZ* o_conv = (LDKCResult_PrivateRouteCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PrivateRouteCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_PrivateRouteCreationErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PrivateRouteCreationErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
+ *ret_conv = CResult_PrivateRouteCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PrivateRouteCreationErrorZ* arg_conv = (LDKCResult_PrivateRouteCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PrivateRouteCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_PrivateRouteCreationErrorZ_clone(uint32_t orig) {
LDKCResult_PrivateRouteCreationErrorZ* orig_conv = (LDKCResult_PrivateRouteCreationErrorZ*)(orig & ~1);
LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_StringErrorZ_is_ok(uint32_t o) {
+ LDKCResult_StringErrorZ* o_conv = (LDKCResult_StringErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_StringErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_StringErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKChannelMonitorUpdate o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelMonitorUpdate_clone(&o_conv);
LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
*ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
*ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* o_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
+ *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* arg_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ChannelMonitorUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
return (uint64_t)ret_conv;
}
+uint32_t __attribute__((visibility("default"))) TS_COption_MonitorEventZ_some(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKMonitorEvent o_conv = *(LDKMonitorEvent*)(o_ptr);
+ o_conv = MonitorEvent_clone((LDKMonitorEvent*)(((uint64_t)o) & ~1));
+ LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
+ *ret_copy = COption_MonitorEventZ_some(o_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_MonitorEventZ_none() {
+ LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
+ *ret_copy = COption_MonitorEventZ_none();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_COption_MonitorEventZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_MonitorEventZ _res_conv = *(LDKCOption_MonitorEventZ*)(_res_ptr);
+ FREE((void*)_res);
+ COption_MonitorEventZ_free(_res_conv);
+}
+
+static inline uint64_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg) {
+ LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
+ *ret_copy = COption_MonitorEventZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_MonitorEventZ_clone_ptr(uint32_t arg) {
+ LDKCOption_MonitorEventZ* arg_conv = (LDKCOption_MonitorEventZ*)arg;
+ int64_t ret_val = COption_MonitorEventZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_MonitorEventZ_clone(uint32_t orig) {
+ LDKCOption_MonitorEventZ* orig_conv = (LDKCOption_MonitorEventZ*)orig;
+ LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
+ *ret_copy = COption_MonitorEventZ_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKCOption_MonitorEventZ o_conv = *(LDKCOption_MonitorEventZ*)(o_ptr);
+ o_conv = COption_MonitorEventZ_clone((LDKCOption_MonitorEventZ*)(((uint64_t)o) & ~1));
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* o_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_COption_MonitorEventZDecodeErrorZ _res_conv = *(LDKCResult_COption_MonitorEventZDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_COption_MonitorEventZDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* arg_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* orig_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(orig & ~1);
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_HTLCUpdateDecodeErrorZ_ok(uint32_t o) {
LDKHTLCUpdate o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = HTLCUpdate_clone(&o_conv);
LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
*ret_conv = CResult_HTLCUpdateDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
*ret_conv = CResult_HTLCUpdateDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_HTLCUpdateDecodeErrorZ* o_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_HTLCUpdateDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_HTLCUpdateDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_HTLCUpdateDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
+ *ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_HTLCUpdateDecodeErrorZ* arg_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_HTLCUpdateDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_HTLCUpdateDecodeErrorZ* orig_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(orig & ~1);
LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
LDKMonitorUpdateError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = MonitorUpdateError_clone(&e_conv);
LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
*ret_conv = CResult_NoneMonitorUpdateErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NoneMonitorUpdateErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NoneMonitorUpdateErrorZ* o_conv = (LDKCResult_NoneMonitorUpdateErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneMonitorUpdateErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NoneMonitorUpdateErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneMonitorUpdateErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneMonitorUpdateErrorZ_clone_ptr(LDKCResult_NoneMonitorUpdateErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
+ *ret_conv = CResult_NoneMonitorUpdateErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NoneMonitorUpdateErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NoneMonitorUpdateErrorZ* arg_conv = (LDKCResult_NoneMonitorUpdateErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneMonitorUpdateErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NoneMonitorUpdateErrorZ_clone(uint32_t orig) {
LDKCResult_NoneMonitorUpdateErrorZ* orig_conv = (LDKCResult_NoneMonitorUpdateErrorZ*)(orig & ~1);
LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg) {
+ LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
+ *ret_conv = C2Tuple_OutPointScriptZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_OutPointScriptZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_OutPointScriptZ* arg_conv = (LDKC2Tuple_OutPointScriptZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_OutPointScriptZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C2Tuple_OutPointScriptZ_clone(uint32_t orig) {
LDKC2Tuple_OutPointScriptZ* orig_conv = (LDKC2Tuple_OutPointScriptZ*)(orig & ~1);
LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
LDKOutPoint a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = OutPoint_clone(&a_conv);
LDKCVec_u8Z b_ref;
b_ref.datalen = *((uint32_t*)b);
C2Tuple_OutPointScriptZ_free(_res_conv);
}
+static inline uint64_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg) {
+ LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
+ *ret_conv = C2Tuple_u32ScriptZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_u32ScriptZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_u32ScriptZ* arg_conv = (LDKC2Tuple_u32ScriptZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_u32ScriptZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C2Tuple_u32ScriptZ_clone(uint32_t orig) {
LDKC2Tuple_u32ScriptZ* orig_conv = (LDKC2Tuple_u32ScriptZ*)(orig & ~1);
LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
CVec_C2Tuple_u32ScriptZZ_free(_res_constr);
}
+static inline uint64_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg) {
+ LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
+ *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* arg_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(uint32_t orig) {
LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(orig & ~1);
LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
CVec_TransactionZ_free(_res_constr);
}
+static inline uint64_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg) {
+ LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
+ *ret_conv = C2Tuple_u32TxOutZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_u32TxOutZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_u32TxOutZ* arg_conv = (LDKC2Tuple_u32TxOutZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_u32TxOutZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C2Tuple_u32TxOutZ_clone(uint32_t orig) {
LDKC2Tuple_u32TxOutZ* orig_conv = (LDKC2Tuple_u32TxOutZ*)(orig & ~1);
LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
CVec_C2Tuple_u32TxOutZZ_free(_res_constr);
}
+static inline uint64_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg) {
+ LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
+ *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* arg_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(uint32_t orig) {
LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(orig & ~1);
LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
*ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* o_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
+ *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* arg_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* orig_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(orig & ~1);
LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
LDKLightningError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = LightningError_clone(&e_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = CResult_NoneLightningErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NoneLightningErrorZ* o_conv = (LDKCResult_NoneLightningErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneLightningErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneLightningErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
+ *ret_conv = CResult_NoneLightningErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NoneLightningErrorZ* arg_conv = (LDKCResult_NoneLightningErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneLightningErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_clone(uint32_t orig) {
LDKCResult_NoneLightningErrorZ* orig_conv = (LDKCResult_NoneLightningErrorZ*)(orig & ~1);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg) {
+ LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
+ *ret_conv = C2Tuple_PublicKeyTypeZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_PublicKeyTypeZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_PublicKeyTypeZ* arg_conv = (LDKC2Tuple_PublicKeyTypeZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_PublicKeyTypeZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PublicKeyTypeZ_clone(uint32_t orig) {
LDKC2Tuple_PublicKeyTypeZ* orig_conv = (LDKC2Tuple_PublicKeyTypeZ*)(orig & ~1);
LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
LDKLightningError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = LightningError_clone(&e_conv);
LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
*ret_conv = CResult_boolLightningErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_is_ok(uint32_t o) {
+ LDKCResult_boolLightningErrorZ* o_conv = (LDKCResult_boolLightningErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_boolLightningErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_boolLightningErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg) {
+ LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
+ *ret_conv = CResult_boolLightningErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_boolLightningErrorZ* arg_conv = (LDKCResult_boolLightningErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_boolLightningErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_clone(uint32_t orig) {
LDKCResult_boolLightningErrorZ* orig_conv = (LDKCResult_boolLightningErrorZ*)(orig & ~1);
LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg) {
+ LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
+ *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(uint32_t arg) {
+ LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* arg_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(arg & ~1);
+ int64_t ret_val = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(uint32_t orig) {
LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* orig_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(orig & ~1);
LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
LDKChannelAnnouncement a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = ChannelAnnouncement_clone(&a_conv);
LDKChannelUpdate b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = (b & 1) || (b == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
b_conv = ChannelUpdate_clone(&b_conv);
LDKChannelUpdate c_conv;
c_conv.inner = (void*)(c & (~1));
c_conv.is_owned = (c & 1) || (c == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(c_conv);
c_conv = ChannelUpdate_clone(&c_conv);
LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
*ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a_conv, b_conv, c_conv);
LDKNodeAnnouncement _res_conv_18_conv;
_res_conv_18_conv.inner = (void*)(_res_conv_18 & (~1));
_res_conv_18_conv.is_owned = (_res_conv_18 & 1) || (_res_conv_18 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_18_conv);
_res_constr.data[s] = _res_conv_18_conv;
}
CVec_NodeAnnouncementZ_free(_res_constr);
LDKPeerHandleError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = PeerHandleError_clone(&e_conv);
LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
*ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(uint32_t o) {
+ LDKCResult_CVec_u8ZPeerHandleErrorZ* o_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CVec_u8ZPeerHandleErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
+ *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_CVec_u8ZPeerHandleErrorZ* arg_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(uint32_t orig) {
LDKCResult_CVec_u8ZPeerHandleErrorZ* orig_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(orig & ~1);
LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
LDKPeerHandleError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = PeerHandleError_clone(&e_conv);
LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
*ret_conv = CResult_NonePeerHandleErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NonePeerHandleErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NonePeerHandleErrorZ* o_conv = (LDKCResult_NonePeerHandleErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NonePeerHandleErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NonePeerHandleErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NonePeerHandleErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
+ *ret_conv = CResult_NonePeerHandleErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NonePeerHandleErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NonePeerHandleErrorZ* arg_conv = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NonePeerHandleErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NonePeerHandleErrorZ_clone(uint32_t orig) {
LDKCResult_NonePeerHandleErrorZ* orig_conv = (LDKCResult_NonePeerHandleErrorZ*)(orig & ~1);
LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
LDKPeerHandleError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = PeerHandleError_clone(&e_conv);
LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
*ret_conv = CResult_boolPeerHandleErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_boolPeerHandleErrorZ_is_ok(uint32_t o) {
+ LDKCResult_boolPeerHandleErrorZ* o_conv = (LDKCResult_boolPeerHandleErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_boolPeerHandleErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_boolPeerHandleErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_boolPeerHandleErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg) {
+ LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
+ *ret_conv = CResult_boolPeerHandleErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_boolPeerHandleErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_boolPeerHandleErrorZ* arg_conv = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_boolPeerHandleErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_boolPeerHandleErrorZ_clone(uint32_t orig) {
LDKCResult_boolPeerHandleErrorZ* orig_conv = (LDKCResult_boolPeerHandleErrorZ*)(orig & ~1);
LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
LDKNodeId o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NodeId_clone(&o_conv);
LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
*ret_conv = CResult_NodeIdDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
+ *ret_conv = CResult_NodeIdDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_NodeIdDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NodeIdDecodeErrorZ* o_conv = (LDKCResult_NodeIdDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeIdDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_NodeIdDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_NodeIdDecodeErrorZ _res_conv = *(LDKCResult_NodeIdDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_NodeIdDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
+ *ret_conv = CResult_NodeIdDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NodeIdDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NodeIdDecodeErrorZ* arg_conv = (LDKCResult_NodeIdDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NodeIdDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NodeIdDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_NodeIdDecodeErrorZ* orig_conv = (LDKCResult_NodeIdDecodeErrorZ*)(orig & ~1);
+ LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
+ *ret_conv = CResult_NodeIdDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKCOption_NetworkUpdateZ o_conv = *(LDKCOption_NetworkUpdateZ*)(o_ptr);
+ o_conv = COption_NetworkUpdateZ_clone((LDKCOption_NetworkUpdateZ*)(((uint64_t)o) & ~1));
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
- LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
- *ret_conv = CResult_NodeIdDecodeErrorZ_err(e_conv);
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
-void __attribute__((visibility("default"))) TS_CResult_NodeIdDecodeErrorZ_free(uint32_t _res) {
+jboolean __attribute__((visibility("default"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* o_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CHECK_ACCESS(_res_ptr);
- LDKCResult_NodeIdDecodeErrorZ _res_conv = *(LDKCResult_NodeIdDecodeErrorZ*)(_res_ptr);
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res_conv = *(LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(_res_ptr);
FREE((void*)_res);
- CResult_NodeIdDecodeErrorZ_free(_res_conv);
+ CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res_conv);
}
-uint32_t __attribute__((visibility("default"))) TS_CResult_NodeIdDecodeErrorZ_clone(uint32_t orig) {
- LDKCResult_NodeIdDecodeErrorZ* orig_conv = (LDKCResult_NodeIdDecodeErrorZ*)(orig & ~1);
- LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
- *ret_conv = CResult_NodeIdDecodeErrorZ_clone(orig_conv);
+static inline uint64_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* arg_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* orig_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(orig & ~1);
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig_conv);
return (uint64_t)ret_conv;
}
LDKDirectionalChannelInfo o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = DirectionalChannelInfo_clone(&o_conv);
LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
*ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
*ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_DirectionalChannelInfoDecodeErrorZ* o_conv = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_DirectionalChannelInfoDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_DirectionalChannelInfoDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
+ *ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_DirectionalChannelInfoDecodeErrorZ* arg_conv = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_DirectionalChannelInfoDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_DirectionalChannelInfoDecodeErrorZ* orig_conv = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(orig & ~1);
LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
LDKChannelInfo o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelInfo_clone(&o_conv);
LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
*ret_conv = CResult_ChannelInfoDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
*ret_conv = CResult_ChannelInfoDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelInfoDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelInfoDecodeErrorZ* o_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelInfoDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ChannelInfoDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelInfoDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
+ *ret_conv = CResult_ChannelInfoDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ChannelInfoDecodeErrorZ* arg_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelInfoDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ChannelInfoDecodeErrorZ* orig_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
LDKRoutingFees o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RoutingFees_clone(&o_conv);
LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
*ret_conv = CResult_RoutingFeesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
*ret_conv = CResult_RoutingFeesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_RoutingFeesDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_RoutingFeesDecodeErrorZ* o_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RoutingFeesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_RoutingFeesDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RoutingFeesDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
+ *ret_conv = CResult_RoutingFeesDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_RoutingFeesDecodeErrorZ* arg_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_RoutingFeesDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_RoutingFeesDecodeErrorZ* orig_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(orig & ~1);
LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
LDKNodeAnnouncementInfo o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NodeAnnouncementInfo_clone(&o_conv);
LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
*ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
*ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ* o_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
+ *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ* arg_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_NodeAnnouncementInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(orig & ~1);
LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
LDKNodeInfo o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NodeInfo_clone(&o_conv);
LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
*ret_conv = CResult_NodeInfoDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
*ret_conv = CResult_NodeInfoDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NodeInfoDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NodeInfoDecodeErrorZ* o_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeInfoDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NodeInfoDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NodeInfoDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
+ *ret_conv = CResult_NodeInfoDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NodeInfoDecodeErrorZ* arg_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NodeInfoDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NodeInfoDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_NodeInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(orig & ~1);
LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
LDKNetworkGraph o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NetworkGraph_clone(&o_conv);
LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
*ret_conv = CResult_NetworkGraphDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
*ret_conv = CResult_NetworkGraphDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NetworkGraphDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NetworkGraphDecodeErrorZ* o_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NetworkGraphDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NetworkGraphDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NetworkGraphDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NetworkGraphDecodeErrorZ_clone_ptr(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
+ *ret_conv = CResult_NetworkGraphDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NetworkGraphDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NetworkGraphDecodeErrorZ* arg_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NetworkGraphDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NetworkGraphDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_NetworkGraphDecodeErrorZ* orig_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)(orig & ~1);
LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
COption_CVec_NetAddressZZ_free(_res_conv);
}
+static inline uint64_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg) {
+ LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
+ *ret_copy = COption_CVec_NetAddressZZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_CVec_NetAddressZZ_clone_ptr(uint32_t arg) {
+ LDKCOption_CVec_NetAddressZZ* arg_conv = (LDKCOption_CVec_NetAddressZZ*)arg;
+ int64_t ret_val = COption_CVec_NetAddressZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_COption_CVec_NetAddressZZ_clone(uint32_t orig) {
LDKCOption_CVec_NetAddressZZ* orig_conv = (LDKCOption_CVec_NetAddressZZ*)orig;
LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
*ret_conv = CResult_NetAddressDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NetAddressDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NetAddressDecodeErrorZ* o_conv = (LDKCResult_NetAddressDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NetAddressDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NetAddressDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NetAddressDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
+ *ret_conv = CResult_NetAddressDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NetAddressDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NetAddressDecodeErrorZ* arg_conv = (LDKCResult_NetAddressDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NetAddressDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NetAddressDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_NetAddressDecodeErrorZ* orig_conv = (LDKCResult_NetAddressDecodeErrorZ*)(orig & ~1);
LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
LDKUpdateAddHTLC _res_conv_15_conv;
_res_conv_15_conv.inner = (void*)(_res_conv_15 & (~1));
_res_conv_15_conv.is_owned = (_res_conv_15 & 1) || (_res_conv_15 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_15_conv);
_res_constr.data[p] = _res_conv_15_conv;
}
CVec_UpdateAddHTLCZ_free(_res_constr);
LDKUpdateFulfillHTLC _res_conv_19_conv;
_res_conv_19_conv.inner = (void*)(_res_conv_19 & (~1));
_res_conv_19_conv.is_owned = (_res_conv_19 & 1) || (_res_conv_19 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_19_conv);
_res_constr.data[t] = _res_conv_19_conv;
}
CVec_UpdateFulfillHTLCZ_free(_res_constr);
LDKUpdateFailHTLC _res_conv_16_conv;
_res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
_res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
_res_constr.data[q] = _res_conv_16_conv;
}
CVec_UpdateFailHTLCZ_free(_res_constr);
LDKUpdateFailMalformedHTLC _res_conv_25_conv;
_res_conv_25_conv.inner = (void*)(_res_conv_25 & (~1));
_res_conv_25_conv.is_owned = (_res_conv_25 & 1) || (_res_conv_25 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_25_conv);
_res_constr.data[z] = _res_conv_25_conv;
}
CVec_UpdateFailMalformedHTLCZ_free(_res_constr);
LDKAcceptChannel o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = AcceptChannel_clone(&o_conv);
LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
*ret_conv = CResult_AcceptChannelDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
*ret_conv = CResult_AcceptChannelDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_AcceptChannelDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_AcceptChannelDecodeErrorZ* o_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_AcceptChannelDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_AcceptChannelDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_AcceptChannelDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
+ *ret_conv = CResult_AcceptChannelDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_AcceptChannelDecodeErrorZ* arg_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_AcceptChannelDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_AcceptChannelDecodeErrorZ* orig_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(orig & ~1);
LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
LDKAnnouncementSignatures o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = AnnouncementSignatures_clone(&o_conv);
LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
*ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
*ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ* o_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_AnnouncementSignaturesDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
+ *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ* arg_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_AnnouncementSignaturesDecodeErrorZ* orig_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(orig & ~1);
LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
LDKChannelReestablish o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelReestablish_clone(&o_conv);
LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
*ret_conv = CResult_ChannelReestablishDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
*ret_conv = CResult_ChannelReestablishDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelReestablishDecodeErrorZ* o_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelReestablishDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ChannelReestablishDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelReestablishDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
+ *ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ChannelReestablishDecodeErrorZ* arg_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelReestablishDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ChannelReestablishDecodeErrorZ* orig_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
LDKClosingSigned o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ClosingSigned_clone(&o_conv);
LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
*ret_conv = CResult_ClosingSignedDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
*ret_conv = CResult_ClosingSignedDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ClosingSignedDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ClosingSignedDecodeErrorZ* o_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ClosingSignedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ClosingSignedDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ClosingSignedDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
+ *ret_conv = CResult_ClosingSignedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ClosingSignedDecodeErrorZ* arg_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ClosingSignedDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ClosingSignedDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(orig & ~1);
LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
LDKClosingSignedFeeRange o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ClosingSignedFeeRange_clone(&o_conv);
LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
*ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
*ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* o_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
+ *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* arg_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(orig & ~1);
LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
LDKCommitmentSigned o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = CommitmentSigned_clone(&o_conv);
LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
*ret_conv = CResult_CommitmentSignedDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
*ret_conv = CResult_CommitmentSignedDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_CommitmentSignedDecodeErrorZ* o_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CommitmentSignedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_CommitmentSignedDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CommitmentSignedDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
+ *ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_CommitmentSignedDecodeErrorZ* arg_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_CommitmentSignedDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_CommitmentSignedDecodeErrorZ* orig_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(orig & ~1);
LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
LDKFundingCreated o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = FundingCreated_clone(&o_conv);
LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
*ret_conv = CResult_FundingCreatedDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
*ret_conv = CResult_FundingCreatedDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_FundingCreatedDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_FundingCreatedDecodeErrorZ* o_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_FundingCreatedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_FundingCreatedDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_FundingCreatedDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
+ *ret_conv = CResult_FundingCreatedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_FundingCreatedDecodeErrorZ* arg_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_FundingCreatedDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_FundingCreatedDecodeErrorZ* orig_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(orig & ~1);
LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
LDKFundingSigned o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = FundingSigned_clone(&o_conv);
LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
*ret_conv = CResult_FundingSignedDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
*ret_conv = CResult_FundingSignedDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_FundingSignedDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_FundingSignedDecodeErrorZ* o_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_FundingSignedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_FundingSignedDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_FundingSignedDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
+ *ret_conv = CResult_FundingSignedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_FundingSignedDecodeErrorZ* arg_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_FundingSignedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_FundingSignedDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_FundingSignedDecodeErrorZ* orig_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(orig & ~1);
LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
LDKFundingLocked o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = FundingLocked_clone(&o_conv);
LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
*ret_conv = CResult_FundingLockedDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
*ret_conv = CResult_FundingLockedDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_FundingLockedDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_FundingLockedDecodeErrorZ* o_conv = (LDKCResult_FundingLockedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_FundingLockedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_FundingLockedDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_FundingLockedDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_FundingLockedDecodeErrorZ_clone_ptr(LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
+ *ret_conv = CResult_FundingLockedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_FundingLockedDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_FundingLockedDecodeErrorZ* arg_conv = (LDKCResult_FundingLockedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_FundingLockedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_FundingLockedDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_FundingLockedDecodeErrorZ* orig_conv = (LDKCResult_FundingLockedDecodeErrorZ*)(orig & ~1);
LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
LDKInit o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Init_clone(&o_conv);
LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
*ret_conv = CResult_InitDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
*ret_conv = CResult_InitDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_InitDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_InitDecodeErrorZ* o_conv = (LDKCResult_InitDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InitDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_InitDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_InitDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
+ *ret_conv = CResult_InitDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_InitDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_InitDecodeErrorZ* arg_conv = (LDKCResult_InitDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_InitDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_InitDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_InitDecodeErrorZ* orig_conv = (LDKCResult_InitDecodeErrorZ*)(orig & ~1);
LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
LDKOpenChannel o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = OpenChannel_clone(&o_conv);
LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
*ret_conv = CResult_OpenChannelDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
*ret_conv = CResult_OpenChannelDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_OpenChannelDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_OpenChannelDecodeErrorZ* o_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_OpenChannelDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_OpenChannelDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_OpenChannelDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
+ *ret_conv = CResult_OpenChannelDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_OpenChannelDecodeErrorZ* arg_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_OpenChannelDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_OpenChannelDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_OpenChannelDecodeErrorZ* orig_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(orig & ~1);
LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
LDKRevokeAndACK o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RevokeAndACK_clone(&o_conv);
LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
*ret_conv = CResult_RevokeAndACKDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
*ret_conv = CResult_RevokeAndACKDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_RevokeAndACKDecodeErrorZ* o_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RevokeAndACKDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_RevokeAndACKDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RevokeAndACKDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
+ *ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_RevokeAndACKDecodeErrorZ* arg_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_RevokeAndACKDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_RevokeAndACKDecodeErrorZ* orig_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(orig & ~1);
LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
LDKShutdown o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Shutdown_clone(&o_conv);
LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
*ret_conv = CResult_ShutdownDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
*ret_conv = CResult_ShutdownDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ShutdownDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ShutdownDecodeErrorZ* o_conv = (LDKCResult_ShutdownDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ShutdownDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ShutdownDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ShutdownDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
+ *ret_conv = CResult_ShutdownDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ShutdownDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ShutdownDecodeErrorZ* arg_conv = (LDKCResult_ShutdownDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ShutdownDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ShutdownDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ShutdownDecodeErrorZ* orig_conv = (LDKCResult_ShutdownDecodeErrorZ*)(orig & ~1);
LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
LDKUpdateFailHTLC o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UpdateFailHTLC_clone(&o_conv);
LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UpdateFailHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UpdateFailHTLCDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UpdateFailHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_UpdateFailHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(orig & ~1);
LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
LDKUpdateFailMalformedHTLC o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UpdateFailMalformedHTLC_clone(&o_conv);
LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(orig & ~1);
LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
LDKUpdateFee o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UpdateFee_clone(&o_conv);
LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
*ret_conv = CResult_UpdateFeeDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
*ret_conv = CResult_UpdateFeeDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_UpdateFeeDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UpdateFeeDecodeErrorZ* o_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateFeeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_UpdateFeeDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UpdateFeeDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
+ *ret_conv = CResult_UpdateFeeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UpdateFeeDecodeErrorZ* arg_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFeeDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_UpdateFeeDecodeErrorZ* orig_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(orig & ~1);
LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
LDKUpdateFulfillHTLC o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UpdateFulfillHTLC_clone(&o_conv);
LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_UpdateFulfillHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(orig & ~1);
LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
LDKUpdateAddHTLC o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UpdateAddHTLC_clone(&o_conv);
LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UpdateAddHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UpdateAddHTLCDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UpdateAddHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_UpdateAddHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(orig & ~1);
LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
LDKPing o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Ping_clone(&o_conv);
LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
*ret_conv = CResult_PingDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
*ret_conv = CResult_PingDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_PingDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PingDecodeErrorZ* o_conv = (LDKCResult_PingDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PingDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_PingDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PingDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
+ *ret_conv = CResult_PingDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PingDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PingDecodeErrorZ* arg_conv = (LDKCResult_PingDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PingDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_PingDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_PingDecodeErrorZ* orig_conv = (LDKCResult_PingDecodeErrorZ*)(orig & ~1);
LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
LDKPong o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Pong_clone(&o_conv);
LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
*ret_conv = CResult_PongDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
*ret_conv = CResult_PongDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_PongDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PongDecodeErrorZ* o_conv = (LDKCResult_PongDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PongDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_PongDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PongDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
+ *ret_conv = CResult_PongDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PongDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PongDecodeErrorZ* arg_conv = (LDKCResult_PongDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PongDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_PongDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_PongDecodeErrorZ* orig_conv = (LDKCResult_PongDecodeErrorZ*)(orig & ~1);
LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
LDKUnsignedChannelAnnouncement o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UnsignedChannelAnnouncement_clone(&o_conv);
LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
*ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
*ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* o_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(orig & ~1);
LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
LDKChannelAnnouncement o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelAnnouncement_clone(&o_conv);
LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
*ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
*ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelAnnouncementDecodeErrorZ* o_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelAnnouncementDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ChannelAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
LDKUnsignedChannelUpdate o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UnsignedChannelUpdate_clone(&o_conv);
LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
*ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
*ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ* o_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
+ *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ* arg_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_UnsignedChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(orig & ~1);
LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
LDKChannelUpdate o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelUpdate_clone(&o_conv);
LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
*ret_conv = CResult_ChannelUpdateDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
*ret_conv = CResult_ChannelUpdateDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelUpdateDecodeErrorZ* o_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelUpdateDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ChannelUpdateDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelUpdateDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
+ *ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ChannelUpdateDecodeErrorZ* arg_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelUpdateDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
LDKErrorMessage o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ErrorMessage_clone(&o_conv);
LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
*ret_conv = CResult_ErrorMessageDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
*ret_conv = CResult_ErrorMessageDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ErrorMessageDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ErrorMessageDecodeErrorZ* o_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ErrorMessageDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ErrorMessageDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ErrorMessageDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
+ *ret_conv = CResult_ErrorMessageDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ErrorMessageDecodeErrorZ* arg_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ErrorMessageDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ErrorMessageDecodeErrorZ* orig_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(orig & ~1);
LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
LDKUnsignedNodeAnnouncement o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UnsignedNodeAnnouncement_clone(&o_conv);
LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
*ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
*ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* o_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(orig & ~1);
LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
LDKNodeAnnouncement o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NodeAnnouncement_clone(&o_conv);
LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
*ret_conv = CResult_NodeAnnouncementDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
*ret_conv = CResult_NodeAnnouncementDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NodeAnnouncementDecodeErrorZ* o_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeAnnouncementDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NodeAnnouncementDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NodeAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_NodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(orig & ~1);
LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
LDKQueryShortChannelIds o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = QueryShortChannelIds_clone(&o_conv);
LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
*ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
*ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ* o_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_QueryShortChannelIdsDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
+ *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ* arg_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_QueryShortChannelIdsDecodeErrorZ* orig_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(orig & ~1);
LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
LDKReplyShortChannelIdsEnd o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ReplyShortChannelIdsEnd_clone(&o_conv);
LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
*ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
*ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* o_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
+ *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* arg_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* orig_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(orig & ~1);
LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
LDKQueryChannelRange o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = QueryChannelRange_clone(&o_conv);
LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
*ret_conv = CResult_QueryChannelRangeDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
*ret_conv = CResult_QueryChannelRangeDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_QueryChannelRangeDecodeErrorZ* o_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_QueryChannelRangeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_QueryChannelRangeDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_QueryChannelRangeDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
+ *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_QueryChannelRangeDecodeErrorZ* arg_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_QueryChannelRangeDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_QueryChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(orig & ~1);
LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
LDKReplyChannelRange o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ReplyChannelRange_clone(&o_conv);
LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
*ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
*ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ReplyChannelRangeDecodeErrorZ* o_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ReplyChannelRangeDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
+ *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ReplyChannelRangeDecodeErrorZ* arg_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ReplyChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(orig & ~1);
LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
LDKGossipTimestampFilter o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = GossipTimestampFilter_clone(&o_conv);
LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
*ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
*ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_GossipTimestampFilterDecodeErrorZ* o_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_GossipTimestampFilterDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
+ *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_GossipTimestampFilterDecodeErrorZ* arg_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_GossipTimestampFilterDecodeErrorZ* orig_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(orig & ~1);
LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
LDKInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Invoice_clone(&o_conv);
LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
*ret_conv = CResult_InvoiceSignOrCreationErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(uint32_t o) {
+ LDKCResult_InvoiceSignOrCreationErrorZ* o_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InvoiceSignOrCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_InvoiceSignOrCreationErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_InvoiceSignOrCreationErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
+ *ret_conv = CResult_InvoiceSignOrCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_InvoiceSignOrCreationErrorZ* arg_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceSignOrCreationErrorZ_clone(uint32_t orig) {
LDKCResult_InvoiceSignOrCreationErrorZ* orig_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)(orig & ~1);
LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
LDKLockedChannelMonitor o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
// Warning: we need a move here but no clone is available for LDKLockedChannelMonitor
LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
*ret_conv = CResult_LockedChannelMonitorNoneZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_LockedChannelMonitorNoneZ_is_ok(uint32_t o) {
+ LDKCResult_LockedChannelMonitorNoneZ* o_conv = (LDKCResult_LockedChannelMonitorNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_LockedChannelMonitorNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_LockedChannelMonitorNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKOutPoint _res_conv_10_conv;
_res_conv_10_conv.inner = (void*)(_res_conv_10 & (~1));
_res_conv_10_conv.is_owned = (_res_conv_10 & 1) || (_res_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_10_conv);
_res_constr.data[k] = _res_conv_10_conv;
}
CVec_OutPointZ_free(_res_constr);
PaymentPurpose_free(this_ptr_conv);
}
+static inline uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg) {
+ LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
+ *ret_copy = PaymentPurpose_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_PaymentPurpose_clone_ptr(uint32_t arg) {
+ LDKPaymentPurpose* arg_conv = (LDKPaymentPurpose*)arg;
+ int64_t ret_val = PaymentPurpose_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_PaymentPurpose_clone(uint32_t orig) {
LDKPaymentPurpose* orig_conv = (LDKPaymentPurpose*)orig;
LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
ClosureReason_free(this_ptr_conv);
}
+static inline uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg) {
+ LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
+ *ret_copy = ClosureReason_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ClosureReason_clone_ptr(uint32_t arg) {
+ LDKClosureReason* arg_conv = (LDKClosureReason*)arg;
+ int64_t ret_val = ClosureReason_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ClosureReason_clone(uint32_t orig) {
LDKClosureReason* orig_conv = (LDKClosureReason*)orig;
LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
return ret_arr;
}
+uint32_t __attribute__((visibility("default"))) TS_ClosureReason_read(int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = *((uint32_t*)ser);
+ ser_ref.data = (int8_t*)(ser + 4);
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = ClosureReason_read(ser_ref);
+ return (uint64_t)ret_conv;
+}
+
void __attribute__((visibility("default"))) TS_Event_free(uint32_t this_ptr) {
if ((this_ptr & 1) != 0) return;
void* this_ptr_ptr = (void*)(((uint64_t)this_ptr) & ~1);
Event_free(this_ptr_conv);
}
+static inline uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg) {
+ LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
+ *ret_copy = Event_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Event_clone_ptr(uint32_t arg) {
+ LDKEvent* arg_conv = (LDKEvent*)arg;
+ int64_t ret_val = Event_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Event_clone(uint32_t orig) {
LDKEvent* orig_conv = (LDKEvent*)orig;
LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
LDKRouteHop path_conv_10_conv;
path_conv_10_conv.inner = (void*)(path_conv_10 & (~1));
path_conv_10_conv.is_owned = (path_conv_10 & 1) || (path_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
path_constr.data[k] = path_conv_10_conv;
}
LDKRouteParameters retry_conv;
retry_conv.inner = (void*)(retry & (~1));
retry_conv.is_owned = (retry & 1) || (retry == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(retry_conv);
retry_conv = RouteParameters_clone(&retry_conv);
LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
*ret_copy = Event_payment_path_failed(payment_id_ref, payment_hash_ref, rejected_by_dest, network_update_conv, all_paths_failed, path_constr, short_channel_id_conv, retry_conv);
return ret_arr;
}
+uint32_t __attribute__((visibility("default"))) TS_Event_read(int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = *((uint32_t*)ser);
+ ser_ref.data = (int8_t*)(ser + 4);
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = Event_read(ser_ref);
+ return (uint64_t)ret_conv;
+}
+
void __attribute__((visibility("default"))) TS_MessageSendEvent_free(uint32_t this_ptr) {
if ((this_ptr & 1) != 0) return;
void* this_ptr_ptr = (void*)(((uint64_t)this_ptr) & ~1);
MessageSendEvent_free(this_ptr_conv);
}
+static inline uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg) {
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_MessageSendEvent_clone_ptr(uint32_t arg) {
+ LDKMessageSendEvent* arg_conv = (LDKMessageSendEvent*)arg;
+ int64_t ret_val = MessageSendEvent_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_clone(uint32_t orig) {
LDKMessageSendEvent* orig_conv = (LDKMessageSendEvent*)orig;
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
LDKAcceptChannel msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = AcceptChannel_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_accept_channel(node_id_ref, msg_conv);
LDKOpenChannel msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = OpenChannel_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_open_channel(node_id_ref, msg_conv);
LDKFundingCreated msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = FundingCreated_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_funding_created(node_id_ref, msg_conv);
LDKFundingSigned msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = FundingSigned_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_funding_signed(node_id_ref, msg_conv);
LDKFundingLocked msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = FundingLocked_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_funding_locked(node_id_ref, msg_conv);
LDKAnnouncementSignatures msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = AnnouncementSignatures_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_announcement_signatures(node_id_ref, msg_conv);
LDKCommitmentUpdate updates_conv;
updates_conv.inner = (void*)(updates & (~1));
updates_conv.is_owned = (updates & 1) || (updates == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_conv);
updates_conv = CommitmentUpdate_clone(&updates_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_update_htlcs(node_id_ref, updates_conv);
LDKRevokeAndACK msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = RevokeAndACK_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_revoke_and_ack(node_id_ref, msg_conv);
LDKClosingSigned msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ClosingSigned_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_closing_signed(node_id_ref, msg_conv);
LDKShutdown msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = Shutdown_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_shutdown(node_id_ref, msg_conv);
LDKChannelReestablish msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ChannelReestablish_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_channel_reestablish(node_id_ref, msg_conv);
LDKChannelAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ChannelAnnouncement_clone(&msg_conv);
LDKChannelUpdate update_msg_conv;
update_msg_conv.inner = (void*)(update_msg & (~1));
update_msg_conv.is_owned = (update_msg & 1) || (update_msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_conv);
update_msg_conv = ChannelUpdate_clone(&update_msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_broadcast_channel_announcement(msg_conv, update_msg_conv);
LDKNodeAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = NodeAnnouncement_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_broadcast_node_announcement(msg_conv);
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ChannelUpdate_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_broadcast_channel_update(msg_conv);
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ChannelUpdate_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_channel_update(node_id_ref, msg_conv);
LDKQueryChannelRange msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = QueryChannelRange_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_channel_range_query(node_id_ref, msg_conv);
LDKQueryShortChannelIds msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = QueryShortChannelIds_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_short_ids_query(node_id_ref, msg_conv);
LDKReplyChannelRange msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ReplyChannelRange_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_reply_channel_range(node_id_ref, msg_conv);
APIError_free(this_ptr_conv);
}
+static inline uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg) {
+ LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
+ *ret_copy = APIError_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_APIError_clone_ptr(uint32_t arg) {
+ LDKAPIError* arg_conv = (LDKAPIError*)arg;
+ int64_t ret_val = APIError_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_APIError_clone(uint32_t orig) {
LDKAPIError* orig_conv = (LDKAPIError*)orig;
LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
LDKShutdownScript script_conv;
script_conv.inner = (void*)(script & (~1));
script_conv.is_owned = (script & 1) || (script == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(script_conv);
script_conv = ShutdownScript_clone(&script_conv);
LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
*ret_copy = APIError_incompatible_shutdown_script(script_conv);
return ret_conv;
}
+void __attribute__((visibility("default"))) TS_Record_free(uint32_t this_obj) {
+ LDKRecord this_obj_conv;
+ this_obj_conv.inner = (void*)(this_obj & (~1));
+ this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
+ Record_free(this_obj_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Record_get_level(uint32_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ uint32_t ret_conv = LDKLevel_to_js(Record_get_level(&this_ptr_conv));
+ return ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_Record_set_level(uint32_t this_ptr, uint32_t val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKLevel val_conv = LDKLevel_from_js(val);
+ Record_set_level(&this_ptr_conv, val_conv);
+}
+
+jstring __attribute__((visibility("default"))) TS_Record_get_args(uint32_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr ret_str = Record_get_args(&this_ptr_conv);
+ jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
+ Str_free(ret_str);
+ return ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_Record_set_args(uint32_t this_ptr, jstring val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr val_conv = str_ref_to_owned_c(val);
+ Record_set_args(&this_ptr_conv, val_conv);
+}
+
+jstring __attribute__((visibility("default"))) TS_Record_get_module_path(uint32_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr ret_str = Record_get_module_path(&this_ptr_conv);
+ jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
+ Str_free(ret_str);
+ return ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_Record_set_module_path(uint32_t this_ptr, jstring val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr val_conv = str_ref_to_owned_c(val);
+ Record_set_module_path(&this_ptr_conv, val_conv);
+}
+
+jstring __attribute__((visibility("default"))) TS_Record_get_file(uint32_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr ret_str = Record_get_file(&this_ptr_conv);
+ jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
+ Str_free(ret_str);
+ return ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_Record_set_file(uint32_t this_ptr, jstring val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr val_conv = str_ref_to_owned_c(val);
+ Record_set_file(&this_ptr_conv, val_conv);
+}
+
+int32_t __attribute__((visibility("default"))) TS_Record_get_line(uint32_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ int32_t ret_val = Record_get_line(&this_ptr_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_Record_set_line(uint32_t this_ptr, int32_t val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ Record_set_line(&this_ptr_conv, val);
+}
+
+static inline uint64_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg) {
+ LDKRecord ret_var = Record_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Record_clone_ptr(uint32_t arg) {
+ LDKRecord arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Record_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Record_clone(uint32_t orig) {
+ LDKRecord orig_conv;
+ orig_conv.inner = (void*)(orig & (~1));
+ orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
+ LDKRecord ret_var = Record_clone(&orig_conv);
+ uint64_t ret_ref = 0;
+ CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = (uint64_t)ret_var.inner;
+ if (ret_var.is_owned) {
+ ret_ref |= 1;
+ }
+ return ret_ref;
+}
+
void __attribute__((visibility("default"))) TS_Logger_free(uint32_t this_ptr) {
if ((this_ptr & 1) != 0) return;
void* this_ptr_ptr = (void*)(((uint64_t)this_ptr) & ~1);
LDKChannelHandshakeConfig this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelHandshakeConfig_free(this_obj_conv);
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ChannelHandshakeConfig_get_minimum_depth(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeConfig_set_minimum_depth(&this_ptr_conv, val);
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = ChannelHandshakeConfig_get_our_to_self_delay(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeConfig_set_our_to_self_delay(&this_ptr_conv, val);
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelHandshakeConfig_get_our_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeConfig_set_our_htlc_minimum_msat(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg) {
+ LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_clone_ptr(uint32_t arg) {
+ LDKChannelHandshakeConfig arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelHandshakeConfig_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_clone(uint32_t orig) {
LDKChannelHandshakeConfig orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelHandshakeLimits this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelHandshakeLimits_free(this_obj_conv);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelHandshakeLimits_get_min_funding_satoshis(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_min_funding_satoshis(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelHandshakeLimits_get_max_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_max_htlc_minimum_msat(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelHandshakeLimits_get_max_channel_reserve_satoshis(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_max_channel_reserve_satoshis(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = ChannelHandshakeLimits_get_min_max_accepted_htlcs(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_min_max_accepted_htlcs(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ChannelHandshakeLimits_get_max_minimum_depth(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_max_minimum_depth(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelHandshakeLimits_get_force_announced_channel_preference(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_force_announced_channel_preference(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = ChannelHandshakeLimits_get_their_to_self_delay(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_their_to_self_delay(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg) {
+ LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_clone_ptr(uint32_t arg) {
+ LDKChannelHandshakeLimits arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelHandshakeLimits_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_clone(uint32_t orig) {
LDKChannelHandshakeLimits orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelConfig this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelConfig_free(this_obj_conv);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ChannelConfig_get_forwarding_fee_proportional_millionths(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_forwarding_fee_proportional_millionths(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ChannelConfig_get_forwarding_fee_base_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_forwarding_fee_base_msat(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = ChannelConfig_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelConfig_get_announced_channel(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_announced_channel(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelConfig_get_commit_upfront_shutdown_pubkey(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_commit_upfront_shutdown_pubkey(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelConfig_get_max_dust_htlc_exposure_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_max_dust_htlc_exposure_msat(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelConfig_get_force_close_avoidance_max_fee_satoshis(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_force_close_avoidance_max_fee_satoshis(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg) {
+ LDKChannelConfig ret_var = ChannelConfig_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelConfig_clone_ptr(uint32_t arg) {
+ LDKChannelConfig arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelConfig_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelConfig_clone(uint32_t orig) {
LDKChannelConfig orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelConfig ret_var = ChannelConfig_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelConfig obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelConfig_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKUserConfig this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UserConfig_free(this_obj_conv);
}
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelHandshakeConfig ret_var = UserConfig_get_own_channel_config(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelHandshakeConfig val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelHandshakeConfig_clone(&val_conv);
UserConfig_set_own_channel_config(&this_ptr_conv, val_conv);
}
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelHandshakeLimits ret_var = UserConfig_get_peer_channel_config_limits(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelHandshakeLimits val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelHandshakeLimits_clone(&val_conv);
UserConfig_set_peer_channel_config_limits(&this_ptr_conv, val_conv);
}
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelConfig ret_var = UserConfig_get_channel_options(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelConfig val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelConfig_clone(&val_conv);
UserConfig_set_channel_options(&this_ptr_conv, val_conv);
}
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = UserConfig_get_accept_forwards_to_priv_channels(&this_ptr_conv);
return ret_val;
}
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UserConfig_set_accept_forwards_to_priv_channels(&this_ptr_conv, val);
}
LDKChannelHandshakeConfig own_channel_config_arg_conv;
own_channel_config_arg_conv.inner = (void*)(own_channel_config_arg & (~1));
own_channel_config_arg_conv.is_owned = (own_channel_config_arg & 1) || (own_channel_config_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(own_channel_config_arg_conv);
own_channel_config_arg_conv = ChannelHandshakeConfig_clone(&own_channel_config_arg_conv);
LDKChannelHandshakeLimits peer_channel_config_limits_arg_conv;
peer_channel_config_limits_arg_conv.inner = (void*)(peer_channel_config_limits_arg & (~1));
peer_channel_config_limits_arg_conv.is_owned = (peer_channel_config_limits_arg & 1) || (peer_channel_config_limits_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(peer_channel_config_limits_arg_conv);
peer_channel_config_limits_arg_conv = ChannelHandshakeLimits_clone(&peer_channel_config_limits_arg_conv);
LDKChannelConfig channel_options_arg_conv;
channel_options_arg_conv.inner = (void*)(channel_options_arg & (~1));
channel_options_arg_conv.is_owned = (channel_options_arg & 1) || (channel_options_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_options_arg_conv);
channel_options_arg_conv = ChannelConfig_clone(&channel_options_arg_conv);
LDKUserConfig ret_var = UserConfig_new(own_channel_config_arg_conv, peer_channel_config_limits_arg_conv, channel_options_arg_conv, accept_forwards_to_priv_channels_arg);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg) {
+ LDKUserConfig ret_var = UserConfig_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_UserConfig_clone_ptr(uint32_t arg) {
+ LDKUserConfig arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UserConfig_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_UserConfig_clone(uint32_t orig) {
LDKUserConfig orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUserConfig ret_var = UserConfig_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKBestBlock this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
BestBlock_free(this_obj_conv);
}
+static inline uint64_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg) {
+ LDKBestBlock ret_var = BestBlock_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_BestBlock_clone_ptr(uint32_t arg) {
+ LDKBestBlock arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = BestBlock_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_BestBlock_clone(uint32_t orig) {
LDKBestBlock orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKBestBlock ret_var = BestBlock_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKBestBlock this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), BestBlock_block_hash(&this_arg_conv).data, 32);
return ret_arr;
LDKBestBlock this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int32_t ret_val = BestBlock_height(&this_arg_conv);
return ret_val;
}
LDKWatchedOutput this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
WatchedOutput_free(this_obj_conv);
}
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), WatchedOutput_get_block_hash(&this_ptr_conv).data, 32);
return ret_arr;
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint ret_var = WatchedOutput_get_outpoint(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = OutPoint_clone(&val_conv);
WatchedOutput_set_outpoint(&this_ptr_conv, val_conv);
}
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKu8slice ret_var = WatchedOutput_get_script_pubkey(&this_ptr_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u8Z val_ref;
val_ref.datalen = *((uint32_t*)val);
val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
LDKOutPoint outpoint_arg_conv;
outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
LDKCVec_u8Z script_pubkey_arg_ref;
script_pubkey_arg_ref.datalen = *((uint32_t*)script_pubkey_arg);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg) {
+ LDKWatchedOutput ret_var = WatchedOutput_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_WatchedOutput_clone_ptr(uint32_t arg) {
+ LDKWatchedOutput arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = WatchedOutput_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_WatchedOutput_clone(uint32_t orig) {
LDKWatchedOutput orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKWatchedOutput ret_var = WatchedOutput_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKWatchedOutput o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = WatchedOutput_hash(&o_conv);
return ret_val;
}
LDKMonitorUpdateId this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
MonitorUpdateId_free(this_obj_conv);
}
+static inline uint64_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg) {
+ LDKMonitorUpdateId ret_var = MonitorUpdateId_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_MonitorUpdateId_clone_ptr(uint32_t arg) {
+ LDKMonitorUpdateId arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = MonitorUpdateId_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_MonitorUpdateId_clone(uint32_t orig) {
LDKMonitorUpdateId orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKMonitorUpdateId ret_var = MonitorUpdateId_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKMonitorUpdateId o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = MonitorUpdateId_hash(&o_conv);
return ret_val;
}
LDKMonitorUpdateId a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKMonitorUpdateId b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = MonitorUpdateId_eq(&a_conv, &b_conv);
return ret_val;
}
LDKLockedChannelMonitor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
LockedChannelMonitor_free(this_obj_conv);
}
LDKChainMonitor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChainMonitor_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_ChannelDetailsZ ignored_channels_constr;
ignored_channels_constr.datalen = *((uint32_t*)ignored_channels);
if (ignored_channels_constr.datalen > 0)
LDKChannelDetails ignored_channels_conv_16_conv;
ignored_channels_conv_16_conv.inner = (void*)(ignored_channels_conv_16 & (~1));
ignored_channels_conv_16_conv.is_owned = (ignored_channels_conv_16 & 1) || (ignored_channels_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ignored_channels_conv_16_conv);
ignored_channels_conv_16_conv = ChannelDetails_clone(&ignored_channels_conv_16_conv);
ignored_channels_constr.data[q] = ignored_channels_conv_16_conv;
}
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKOutPoint funding_txo_conv;
funding_txo_conv.inner = (void*)(funding_txo & (~1));
funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
funding_txo_conv = OutPoint_clone(&funding_txo_conv);
LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
*ret_conv = ChainMonitor_get_monitor(&this_arg_conv, funding_txo_conv);
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_OutPointZ ret_var = ChainMonitor_list_monitors(&this_arg_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_10_ref = 0;
CHECK((((uint64_t)ret_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_10_var);
ret_conv_10_ref = (uint64_t)ret_conv_10_var.inner;
if (ret_conv_10_var.is_owned) {
ret_conv_10_ref |= 1;
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKOutPoint funding_txo_conv;
funding_txo_conv.inner = (void*)(funding_txo & (~1));
funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
funding_txo_conv = OutPoint_clone(&funding_txo_conv);
LDKMonitorUpdateId completed_update_id_conv;
completed_update_id_conv.inner = (void*)(completed_update_id & (~1));
completed_update_id_conv.is_owned = (completed_update_id & 1) || (completed_update_id == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(completed_update_id_conv);
completed_update_id_conv = MonitorUpdateId_clone(&completed_update_id_conv);
LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
*ret_conv = ChainMonitor_channel_monitor_updated(&this_arg_conv, funding_txo_conv, completed_update_id_conv);
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKListen* ret_ret = MALLOC(sizeof(LDKListen), "LDKListen");
*ret_ret = ChainMonitor_as_Listen(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKConfirm* ret_ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
*ret_ret = ChainMonitor_as_Confirm(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKWatch* ret_ret = MALLOC(sizeof(LDKWatch), "LDKWatch");
*ret_ret = ChainMonitor_as_Watch(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKEventsProvider* ret_ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
*ret_ret = ChainMonitor_as_EventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelMonitorUpdate this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelMonitorUpdate_free(this_obj_conv);
}
LDKChannelMonitorUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelMonitorUpdate_get_update_id(&this_ptr_conv);
return ret_val;
}
LDKChannelMonitorUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelMonitorUpdate_set_update_id(&this_ptr_conv, val);
}
+static inline uint64_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg) {
+ LDKChannelMonitorUpdate ret_var = ChannelMonitorUpdate_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelMonitorUpdate_clone_ptr(uint32_t arg) {
+ LDKChannelMonitorUpdate arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelMonitorUpdate_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelMonitorUpdate_clone(uint32_t orig) {
LDKChannelMonitorUpdate orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelMonitorUpdate ret_var = ChannelMonitorUpdate_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelMonitorUpdate obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelMonitorUpdate_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKMonitorUpdateError this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
MonitorUpdateError_free(this_obj_conv);
}
LDKMonitorUpdateError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr ret_str = MonitorUpdateError_get_a(&this_ptr_conv);
jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
Str_free(ret_str);
LDKMonitorUpdateError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr val_conv = str_ref_to_owned_c(val);
MonitorUpdateError_set_a(&this_ptr_conv, val_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t MonitorUpdateError_clone_ptr(LDKMonitorUpdateError *NONNULL_PTR arg) {
+ LDKMonitorUpdateError ret_var = MonitorUpdateError_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_MonitorUpdateError_clone_ptr(uint32_t arg) {
+ LDKMonitorUpdateError arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = MonitorUpdateError_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_MonitorUpdateError_clone(uint32_t orig) {
LDKMonitorUpdateError orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKMonitorUpdateError ret_var = MonitorUpdateError_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
MonitorEvent_free(this_ptr_conv);
}
+static inline uint64_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg) {
+ LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
+ *ret_copy = MonitorEvent_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_MonitorEvent_clone_ptr(uint32_t arg) {
+ LDKMonitorEvent* arg_conv = (LDKMonitorEvent*)arg;
+ int64_t ret_val = MonitorEvent_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_MonitorEvent_clone(uint32_t orig) {
LDKMonitorEvent* orig_conv = (LDKMonitorEvent*)orig;
LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
LDKHTLCUpdate a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = HTLCUpdate_clone(&a_conv);
LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
*ret_copy = MonitorEvent_htlcevent(a_conv);
LDKOutPoint a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = OutPoint_clone(&a_conv);
LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
*ret_copy = MonitorEvent_commitment_tx_confirmed(a_conv);
LDKOutPoint funding_txo_conv;
funding_txo_conv.inner = (void*)(funding_txo & (~1));
funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
funding_txo_conv = OutPoint_clone(&funding_txo_conv);
LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
*ret_copy = MonitorEvent_update_completed(funding_txo_conv, monitor_update_id);
LDKOutPoint a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = OutPoint_clone(&a_conv);
LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
*ret_copy = MonitorEvent_update_failed(a_conv);
return ret_arr;
}
+uint32_t __attribute__((visibility("default"))) TS_MonitorEvent_read(int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = *((uint32_t*)ser);
+ ser_ref.data = (int8_t*)(ser + 4);
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = MonitorEvent_read(ser_ref);
+ return (uint64_t)ret_conv;
+}
+
void __attribute__((visibility("default"))) TS_HTLCUpdate_free(uint32_t this_obj) {
LDKHTLCUpdate this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
HTLCUpdate_free(this_obj_conv);
}
+static inline uint64_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg) {
+ LDKHTLCUpdate ret_var = HTLCUpdate_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_HTLCUpdate_clone_ptr(uint32_t arg) {
+ LDKHTLCUpdate arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = HTLCUpdate_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_HTLCUpdate_clone(uint32_t orig) {
LDKHTLCUpdate orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKHTLCUpdate ret_var = HTLCUpdate_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKHTLCUpdate obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = HTLCUpdate_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
Balance_free(this_ptr_conv);
}
+static inline uint64_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg) {
+ LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
+ *ret_copy = Balance_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Balance_clone_ptr(uint32_t arg) {
+ LDKBalance* arg_conv = (LDKBalance*)arg;
+ int64_t ret_val = Balance_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Balance_clone(uint32_t orig) {
LDKBalance* orig_conv = (LDKBalance*)orig;
LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
LDKChannelMonitor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelMonitor_free(this_obj_conv);
}
+static inline uint64_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg) {
+ LDKChannelMonitor ret_var = ChannelMonitor_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelMonitor_clone_ptr(uint32_t arg) {
+ LDKChannelMonitor arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelMonitor_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelMonitor_clone(uint32_t orig) {
LDKChannelMonitor orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelMonitor ret_var = ChannelMonitor_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelMonitor obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelMonitor_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelMonitorUpdate updates_conv;
updates_conv.inner = (void*)(updates & (~1));
updates_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_conv);
void* broadcaster_ptr = (void*)(((uint64_t)broadcaster) & ~1);
if (!(broadcaster & 1)) { CHECK_ACCESS(broadcaster_ptr); }
LDKBroadcasterInterface* broadcaster_conv = (LDKBroadcasterInterface*)broadcaster_ptr;
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = ChannelMonitor_get_latest_update_id(&this_arg_conv);
return ret_val;
}
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
*ret_conv = ChannelMonitor_get_funding_txo(&this_arg_conv);
return ((uint64_t)ret_conv);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ret_var = ChannelMonitor_get_outputs_to_watch(&this_arg_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* filter_ptr = (void*)(((uint64_t)filter) & ~1);
if (!(filter & 1)) { CHECK_ACCESS(filter_ptr); }
LDKFilter* filter_conv = (LDKFilter*)filter_ptr;
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_MonitorEventZ ret_var = ChannelMonitor_get_and_clear_pending_monitor_events(&this_arg_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_EventZ ret_var = ChannelMonitor_get_and_clear_pending_events(&this_arg_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* logger_ptr = (void*)(((uint64_t)logger) & ~1);
if (!(logger & 1)) { CHECK_ACCESS(logger_ptr); }
LDKLogger* logger_conv = (LDKLogger*)logger_ptr;
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char header_arr[80];
CHECK(*((uint32_t*)header) == 80);
memcpy(header_arr, (uint8_t*)(header + 4), 80);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char header_arr[80];
CHECK(*((uint32_t*)header) == 80);
memcpy(header_arr, (uint8_t*)(header + 4), 80);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char header_arr[80];
CHECK(*((uint32_t*)header) == 80);
memcpy(header_arr, (uint8_t*)(header + 4), 80);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char txid_arr[32];
CHECK(*((uint32_t*)txid) == 32);
memcpy(txid_arr, (uint8_t*)(txid + 4), 32);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char header_arr[80];
CHECK(*((uint32_t*)header) == 80);
memcpy(header_arr, (uint8_t*)(header + 4), 80);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_TxidZ ret_var = ChannelMonitor_get_relevant_txids(&this_arg_conv);
ptrArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native ptrArray Bytes");
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKBestBlock ret_var = ChannelMonitor_current_best_block(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_BalanceZ ret_var = ChannelMonitor_get_claimable_balances(&this_arg_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
LDKOutPoint this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
OutPoint_free(this_obj_conv);
}
LDKOutPoint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *OutPoint_get_txid(&this_ptr_conv), 32);
return ret_arr;
LDKOutPoint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKOutPoint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = OutPoint_get_index(&this_ptr_conv);
return ret_val;
}
LDKOutPoint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OutPoint_set_index(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg) {
+ LDKOutPoint ret_var = OutPoint_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_OutPoint_clone_ptr(uint32_t arg) {
+ LDKOutPoint arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = OutPoint_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_OutPoint_clone(uint32_t orig) {
LDKOutPoint orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKOutPoint ret_var = OutPoint_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKOutPoint a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKOutPoint b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = OutPoint_eq(&a_conv, &b_conv);
return ret_val;
}
LDKOutPoint o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = OutPoint_hash(&o_conv);
return ret_val;
}
LDKOutPoint this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), OutPoint_to_channel_id(&this_arg_conv).data, 32);
return ret_arr;
LDKOutPoint obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = OutPoint_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKDelayedPaymentOutputDescriptor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DelayedPaymentOutputDescriptor_free(this_obj_conv);
}
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint ret_var = DelayedPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = OutPoint_clone(&val_conv);
DelayedPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
}
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), DelayedPaymentOutputDescriptor_get_per_commitment_point(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = DelayedPaymentOutputDescriptor_get_to_self_delay(&this_ptr_conv);
return ret_val;
}
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DelayedPaymentOutputDescriptor_set_to_self_delay(&this_ptr_conv, val);
}
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKTxOut val_conv = *(LDKTxOut*)(val_ptr);
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), DelayedPaymentOutputDescriptor_get_revocation_pubkey(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *DelayedPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv), 32);
return ret_arr;
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = DelayedPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
return ret_val;
}
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DelayedPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
}
LDKOutPoint outpoint_arg_conv;
outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
LDKPublicKey per_commitment_point_arg_ref;
CHECK(*((uint32_t*)per_commitment_point_arg) == 33);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg) {
+ LDKDelayedPaymentOutputDescriptor ret_var = DelayedPaymentOutputDescriptor_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescriptor_clone_ptr(uint32_t arg) {
+ LDKDelayedPaymentOutputDescriptor arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = DelayedPaymentOutputDescriptor_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescriptor_clone(uint32_t orig) {
LDKDelayedPaymentOutputDescriptor orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKDelayedPaymentOutputDescriptor ret_var = DelayedPaymentOutputDescriptor_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDelayedPaymentOutputDescriptor obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = DelayedPaymentOutputDescriptor_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKStaticPaymentOutputDescriptor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
StaticPaymentOutputDescriptor_free(this_obj_conv);
}
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint ret_var = StaticPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = OutPoint_clone(&val_conv);
StaticPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
}
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKTxOut val_conv = *(LDKTxOut*)(val_ptr);
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *StaticPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv), 32);
return ret_arr;
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = StaticPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
return ret_val;
}
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
StaticPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
}
LDKOutPoint outpoint_arg_conv;
outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
void* output_arg_ptr = (void*)(((uint64_t)output_arg) & ~1);
CHECK_ACCESS(output_arg_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg) {
+ LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_StaticPaymentOutputDescriptor_clone_ptr(uint32_t arg) {
+ LDKStaticPaymentOutputDescriptor arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = StaticPaymentOutputDescriptor_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_StaticPaymentOutputDescriptor_clone(uint32_t orig) {
LDKStaticPaymentOutputDescriptor orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKStaticPaymentOutputDescriptor obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = StaticPaymentOutputDescriptor_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
SpendableOutputDescriptor_free(this_ptr_conv);
}
+static inline uint64_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg) {
+ LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
+ *ret_copy = SpendableOutputDescriptor_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_SpendableOutputDescriptor_clone_ptr(uint32_t arg) {
+ LDKSpendableOutputDescriptor* arg_conv = (LDKSpendableOutputDescriptor*)arg;
+ int64_t ret_val = SpendableOutputDescriptor_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_SpendableOutputDescriptor_clone(uint32_t orig) {
LDKSpendableOutputDescriptor* orig_conv = (LDKSpendableOutputDescriptor*)orig;
LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
LDKOutPoint outpoint_conv;
outpoint_conv.inner = (void*)(outpoint & (~1));
outpoint_conv.is_owned = (outpoint & 1) || (outpoint == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_conv);
outpoint_conv = OutPoint_clone(&outpoint_conv);
void* output_ptr = (void*)(((uint64_t)output) & ~1);
CHECK_ACCESS(output_ptr);
LDKDelayedPaymentOutputDescriptor a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = DelayedPaymentOutputDescriptor_clone(&a_conv);
LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
*ret_copy = SpendableOutputDescriptor_delayed_payment_output(a_conv);
LDKStaticPaymentOutputDescriptor a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = StaticPaymentOutputDescriptor_clone(&a_conv);
LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
*ret_copy = SpendableOutputDescriptor_static_payment_output(a_conv);
BaseSign_free(this_ptr_conv);
}
+static inline uint64_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg) {
+ LDKSign* ret_ret = MALLOC(sizeof(LDKSign), "LDKSign");
+ *ret_ret = Sign_clone(arg);
+ return (uint64_t)ret_ret;
+}
+int64_t __attribute__((visibility("default"))) TS_Sign_clone_ptr(uint32_t arg) {
+ void* arg_ptr = (void*)(((uint64_t)arg) & ~1);
+ if (!(arg & 1)) { CHECK_ACCESS(arg_ptr); }
+ LDKSign* arg_conv = (LDKSign*)arg_ptr;
+ int64_t ret_val = Sign_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Sign_clone(uint32_t orig) {
void* orig_ptr = (void*)(((uint64_t)orig) & ~1);
if (!(orig & 1)) { CHECK_ACCESS(orig_ptr); }
LDKInMemorySigner this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InMemorySigner_free(this_obj_conv);
}
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *InMemorySigner_get_funding_key(&this_ptr_conv), 32);
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSecretKey val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.bytes, (uint8_t*)(val + 4), 32);
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *InMemorySigner_get_revocation_base_key(&this_ptr_conv), 32);
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSecretKey val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.bytes, (uint8_t*)(val + 4), 32);
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *InMemorySigner_get_payment_key(&this_ptr_conv), 32);
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSecretKey val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.bytes, (uint8_t*)(val + 4), 32);
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *InMemorySigner_get_delayed_payment_base_key(&this_ptr_conv), 32);
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSecretKey val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.bytes, (uint8_t*)(val + 4), 32);
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *InMemorySigner_get_htlc_base_key(&this_ptr_conv), 32);
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSecretKey val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.bytes, (uint8_t*)(val + 4), 32);
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *InMemorySigner_get_commitment_seed(&this_ptr_conv), 32);
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
InMemorySigner_set_commitment_seed(&this_ptr_conv, val_ref);
}
+static inline uint64_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg) {
+ LDKInMemorySigner ret_var = InMemorySigner_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_InMemorySigner_clone_ptr(uint32_t arg) {
+ LDKInMemorySigner arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = InMemorySigner_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_InMemorySigner_clone(uint32_t orig) {
LDKInMemorySigner orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInMemorySigner ret_var = InMemorySigner_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelPublicKeys ret_var = InMemorySigner_counterparty_pubkeys(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int16_t ret_val = InMemorySigner_counterparty_selected_contest_delay(&this_arg_conv);
return ret_val;
}
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int16_t ret_val = InMemorySigner_holder_selected_contest_delay(&this_arg_conv);
return ret_val;
}
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = InMemorySigner_is_outbound(&this_arg_conv);
return ret_val;
}
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKOutPoint ret_var = InMemorySigner_funding_outpoint(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelTransactionParameters ret_var = InMemorySigner_get_channel_parameters(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTransaction spend_tx_ref;
spend_tx_ref.datalen = *((uint32_t*)spend_tx);
spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
LDKStaticPaymentOutputDescriptor descriptor_conv;
descriptor_conv.inner = (void*)(descriptor & (~1));
descriptor_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(descriptor_conv);
LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
*ret_conv = InMemorySigner_sign_counterparty_payment_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
return (uint64_t)ret_conv;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTransaction spend_tx_ref;
spend_tx_ref.datalen = *((uint32_t*)spend_tx);
spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
LDKDelayedPaymentOutputDescriptor descriptor_conv;
descriptor_conv.inner = (void*)(descriptor & (~1));
descriptor_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(descriptor_conv);
LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
*ret_conv = InMemorySigner_sign_dynamic_p2wsh_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
return (uint64_t)ret_conv;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKBaseSign* ret_ret = MALLOC(sizeof(LDKBaseSign), "LDKBaseSign");
*ret_ret = InMemorySigner_as_BaseSign(&this_arg_conv);
return (uint64_t)ret_ret;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKSign* ret_ret = MALLOC(sizeof(LDKSign), "LDKSign");
*ret_ret = InMemorySigner_as_Sign(&this_arg_conv);
return (uint64_t)ret_ret;
LDKInMemorySigner obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = InMemorySigner_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKKeysManager this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
KeysManager_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKKeysManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char params_arr[32];
CHECK(*((uint32_t*)params) == 32);
memcpy(params_arr, (uint8_t*)(params + 4), 32);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKKeysManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_SpendableOutputDescriptorZ descriptors_constr;
descriptors_constr.datalen = *((uint32_t*)descriptors);
if (descriptors_constr.datalen > 0)
LDKKeysManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKKeysInterface* ret_ret = MALLOC(sizeof(LDKKeysInterface), "LDKKeysInterface");
*ret_ret = KeysManager_as_KeysInterface(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelManager_free(this_obj_conv);
}
LDKChainParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChainParameters_free(this_obj_conv);
}
LDKChainParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
uint32_t ret_conv = LDKNetwork_to_js(ChainParameters_get_network(&this_ptr_conv));
return ret_conv;
}
LDKChainParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNetwork val_conv = LDKNetwork_from_js(val);
ChainParameters_set_network(&this_ptr_conv, val_conv);
}
LDKChainParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKBestBlock ret_var = ChainParameters_get_best_block(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChainParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKBestBlock val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = BestBlock_clone(&val_conv);
ChainParameters_set_best_block(&this_ptr_conv, val_conv);
}
LDKBestBlock best_block_arg_conv;
best_block_arg_conv.inner = (void*)(best_block_arg & (~1));
best_block_arg_conv.is_owned = (best_block_arg & 1) || (best_block_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(best_block_arg_conv);
best_block_arg_conv = BestBlock_clone(&best_block_arg_conv);
LDKChainParameters ret_var = ChainParameters_new(network_arg_conv, best_block_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg) {
+ LDKChainParameters ret_var = ChainParameters_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChainParameters_clone_ptr(uint32_t arg) {
+ LDKChainParameters arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChainParameters_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChainParameters_clone(uint32_t orig) {
LDKChainParameters orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChainParameters ret_var = ChainParameters_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCounterpartyForwardingInfo this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
CounterpartyForwardingInfo_free(this_obj_conv);
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = CounterpartyForwardingInfo_get_fee_base_msat(&this_ptr_conv);
return ret_val;
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
CounterpartyForwardingInfo_set_fee_base_msat(&this_ptr_conv, val);
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = CounterpartyForwardingInfo_get_fee_proportional_millionths(&this_ptr_conv);
return ret_val;
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
CounterpartyForwardingInfo_set_fee_proportional_millionths(&this_ptr_conv, val);
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = CounterpartyForwardingInfo_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
CounterpartyForwardingInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg) {
+ LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_CounterpartyForwardingInfo_clone_ptr(uint32_t arg) {
+ LDKCounterpartyForwardingInfo arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = CounterpartyForwardingInfo_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CounterpartyForwardingInfo_clone(uint32_t orig) {
LDKCounterpartyForwardingInfo orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelCounterparty this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelCounterparty_free(this_obj_conv);
}
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelCounterparty_get_node_id(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInitFeatures ret_var = ChannelCounterparty_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInitFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = InitFeatures_clone(&val_conv);
ChannelCounterparty_set_features(&this_ptr_conv, val_conv);
}
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelCounterparty_get_unspendable_punishment_reserve(&this_ptr_conv);
return ret_val;
}
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelCounterparty_set_unspendable_punishment_reserve(&this_ptr_conv, val);
}
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCounterpartyForwardingInfo ret_var = ChannelCounterparty_get_forwarding_info(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCounterpartyForwardingInfo val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = CounterpartyForwardingInfo_clone(&val_conv);
ChannelCounterparty_set_forwarding_info(&this_ptr_conv, val_conv);
}
LDKInitFeatures features_arg_conv;
features_arg_conv.inner = (void*)(features_arg & (~1));
features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
features_arg_conv = InitFeatures_clone(&features_arg_conv);
LDKCounterpartyForwardingInfo forwarding_info_arg_conv;
forwarding_info_arg_conv.inner = (void*)(forwarding_info_arg & (~1));
forwarding_info_arg_conv.is_owned = (forwarding_info_arg & 1) || (forwarding_info_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(forwarding_info_arg_conv);
forwarding_info_arg_conv = CounterpartyForwardingInfo_clone(&forwarding_info_arg_conv);
LDKChannelCounterparty ret_var = ChannelCounterparty_new(node_id_arg_ref, features_arg_conv, unspendable_punishment_reserve_arg, forwarding_info_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg) {
+ LDKChannelCounterparty ret_var = ChannelCounterparty_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelCounterparty_clone_ptr(uint32_t arg) {
+ LDKChannelCounterparty arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelCounterparty_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelCounterparty_clone(uint32_t orig) {
LDKChannelCounterparty orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelCounterparty ret_var = ChannelCounterparty_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelDetails this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelDetails_free(this_obj_conv);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *ChannelDetails_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelCounterparty ret_var = ChannelDetails_get_counterparty(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelCounterparty val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelCounterparty_clone(&val_conv);
ChannelDetails_set_counterparty(&this_ptr_conv, val_conv);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint ret_var = ChannelDetails_get_funding_txo(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = OutPoint_clone(&val_conv);
ChannelDetails_set_funding_txo(&this_ptr_conv, val_conv);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = ChannelDetails_get_short_channel_id(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelDetails_get_channel_value_satoshis(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_channel_value_satoshis(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = ChannelDetails_get_unspendable_punishment_reserve(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelDetails_get_user_channel_id(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_user_channel_id(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelDetails_get_outbound_capacity_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_outbound_capacity_msat(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelDetails_get_inbound_capacity_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_inbound_capacity_msat(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
*ret_copy = ChannelDetails_get_confirmations_required(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
*ret_copy = ChannelDetails_get_force_close_spend_delay(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u16Z val_conv = *(LDKCOption_u16Z*)(val_ptr);
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelDetails_get_is_outbound(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_is_outbound(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelDetails_get_is_funding_locked(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_is_funding_locked(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelDetails_get_is_usable(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_is_usable(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelDetails_get_is_public(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_is_public(&this_ptr_conv, val);
}
LDKChannelCounterparty counterparty_arg_conv;
counterparty_arg_conv.inner = (void*)(counterparty_arg & (~1));
counterparty_arg_conv.is_owned = (counterparty_arg & 1) || (counterparty_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(counterparty_arg_conv);
counterparty_arg_conv = ChannelCounterparty_clone(&counterparty_arg_conv);
LDKOutPoint funding_txo_arg_conv;
funding_txo_arg_conv.inner = (void*)(funding_txo_arg & (~1));
funding_txo_arg_conv.is_owned = (funding_txo_arg & 1) || (funding_txo_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_arg_conv);
funding_txo_arg_conv = OutPoint_clone(&funding_txo_arg_conv);
void* short_channel_id_arg_ptr = (void*)(((uint64_t)short_channel_id_arg) & ~1);
CHECK_ACCESS(short_channel_id_arg_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg) {
+ LDKChannelDetails ret_var = ChannelDetails_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelDetails_clone_ptr(uint32_t arg) {
+ LDKChannelDetails arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelDetails_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelDetails_clone(uint32_t orig) {
LDKChannelDetails orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelDetails ret_var = ChannelDetails_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
PaymentSendFailure_free(this_ptr_conv);
}
+static inline uint64_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg) {
+ LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
+ *ret_copy = PaymentSendFailure_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_PaymentSendFailure_clone_ptr(uint32_t arg) {
+ LDKPaymentSendFailure* arg_conv = (LDKPaymentSendFailure*)arg;
+ int64_t ret_val = PaymentSendFailure_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_PaymentSendFailure_clone(uint32_t orig) {
LDKPaymentSendFailure* orig_conv = (LDKPaymentSendFailure*)orig;
LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
LDKRouteParameters failed_paths_retry_conv;
failed_paths_retry_conv.inner = (void*)(failed_paths_retry & (~1));
failed_paths_retry_conv.is_owned = (failed_paths_retry & 1) || (failed_paths_retry == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(failed_paths_retry_conv);
failed_paths_retry_conv = RouteParameters_clone(&failed_paths_retry_conv);
LDKThirtyTwoBytes payment_id_ref;
CHECK(*((uint32_t*)payment_id) == 32);
LDKUserConfig config_conv;
config_conv.inner = (void*)(config & (~1));
config_conv.is_owned = (config & 1) || (config == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(config_conv);
config_conv = UserConfig_clone(&config_conv);
LDKChainParameters params_conv;
params_conv.inner = (void*)(params & (~1));
params_conv.is_owned = (params & 1) || (params == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
params_conv = ChainParameters_clone(¶ms_conv);
LDKChannelManager ret_var = ChannelManager_new(fee_est_conv, chain_monitor_conv, tx_broadcaster_conv, logger_conv, keys_manager_conv, config_conv, params_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKUserConfig ret_var = ChannelManager_get_current_default_configuration(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPublicKey their_network_key_ref;
CHECK(*((uint32_t*)their_network_key) == 33);
memcpy(their_network_key_ref.compressed_form, (uint8_t*)(their_network_key + 4), 33);
LDKUserConfig override_config_conv;
override_config_conv.inner = (void*)(override_config & (~1));
override_config_conv.is_owned = (override_config & 1) || (override_config == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(override_config_conv);
override_config_conv = UserConfig_clone(&override_config_conv);
LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
*ret_conv = ChannelManager_create_channel(&this_arg_conv, their_network_key_ref, channel_value_satoshis, push_msat, user_channel_id, override_config_conv);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_channels(&this_arg_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_16_ref = 0;
CHECK((((uint64_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
ret_conv_16_ref = (uint64_t)ret_conv_16_var.inner;
if (ret_conv_16_var.is_owned) {
ret_conv_16_ref |= 1;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_usable_channels(&this_arg_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_16_ref = 0;
CHECK((((uint64_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
ret_conv_16_ref = (uint64_t)ret_conv_16_var.inner;
if (ret_conv_16_var.is_owned) {
ret_conv_16_ref |= 1;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char channel_id_arr[32];
CHECK(*((uint32_t*)channel_id) == 32);
memcpy(channel_id_arr, (uint8_t*)(channel_id + 4), 32);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char channel_id_arr[32];
CHECK(*((uint32_t*)channel_id) == 32);
memcpy(channel_id_arr, (uint8_t*)(channel_id + 4), 32);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char channel_id_arr[32];
CHECK(*((uint32_t*)channel_id) == 32);
memcpy(channel_id_arr, (uint8_t*)(channel_id + 4), 32);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
ChannelManager_force_close_all_channels(&this_arg_conv);
}
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRoute route_conv;
route_conv.inner = (void*)(route & (~1));
route_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
LDKThirtyTwoBytes payment_hash_ref;
CHECK(*((uint32_t*)payment_hash) == 32);
memcpy(payment_hash_ref.data, (uint8_t*)(payment_hash + 4), 32);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRoute route_conv;
route_conv.inner = (void*)(route & (~1));
route_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
LDKThirtyTwoBytes payment_id_ref;
CHECK(*((uint32_t*)payment_id) == 32);
memcpy(payment_id_ref.data, (uint8_t*)(payment_id + 4), 32);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRoute route_conv;
route_conv.inner = (void*)(route & (~1));
route_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
LDKThirtyTwoBytes payment_preimage_ref;
CHECK(*((uint32_t*)payment_preimage) == 32);
memcpy(payment_preimage_ref.data, (uint8_t*)(payment_preimage + 4), 32);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char temporary_channel_id_arr[32];
CHECK(*((uint32_t*)temporary_channel_id) == 32);
memcpy(temporary_channel_id_arr, (uint8_t*)(temporary_channel_id + 4), 32);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKThreeBytes rgb_ref;
CHECK(*((uint32_t*)rgb) == 3);
memcpy(rgb_ref.data, (uint8_t*)(rgb + 4), 3);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
ChannelManager_process_pending_htlc_forwards(&this_arg_conv);
}
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
ChannelManager_timer_tick_occurred(&this_arg_conv);
}
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char payment_hash_arr[32];
CHECK(*((uint32_t*)payment_hash) == 32);
memcpy(payment_hash_arr, (uint8_t*)(payment_hash + 4), 32);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKThirtyTwoBytes payment_preimage_ref;
CHECK(*((uint32_t*)payment_preimage) == 32);
memcpy(payment_preimage_ref.data, (uint8_t*)(payment_preimage + 4), 32);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelManager_get_our_node_id(&this_arg_conv).compressed_form, 33);
return ret_arr;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* min_value_msat_ptr = (void*)(((uint64_t)min_value_msat) & ~1);
CHECK_ACCESS(min_value_msat_ptr);
LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKThirtyTwoBytes payment_hash_ref;
CHECK(*((uint32_t*)payment_hash) == 32);
memcpy(payment_hash_ref.data, (uint8_t*)(payment_hash + 4), 32);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
*ret_ret = ChannelManager_as_MessageSendEventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKEventsProvider* ret_ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
*ret_ret = ChannelManager_as_EventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKListen* ret_ret = MALLOC(sizeof(LDKListen), "LDKListen");
*ret_ret = ChannelManager_as_Listen(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKConfirm* ret_ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
*ret_ret = ChannelManager_as_Confirm(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = ChannelManager_await_persistable_update_timeout(&this_arg_conv, max_wait);
return ret_val;
}
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
ChannelManager_await_persistable_update(&this_arg_conv);
}
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKBestBlock ret_var = ChannelManager_current_best_block(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelMessageHandler* ret_ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
*ret_ret = ChannelManager_as_ChannelMessageHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelManager_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKChannelManagerReadArgs this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelManagerReadArgs_free(this_obj_conv);
}
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)ChannelManagerReadArgs_get_keys_manager(&this_ptr_conv)) | 1;
return ret_ret;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKKeysInterface val_conv = *(LDKKeysInterface*)(val_ptr);
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)ChannelManagerReadArgs_get_fee_estimator(&this_ptr_conv)) | 1;
return ret_ret;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKFeeEstimator val_conv = *(LDKFeeEstimator*)(val_ptr);
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)ChannelManagerReadArgs_get_chain_monitor(&this_ptr_conv)) | 1;
return ret_ret;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKWatch val_conv = *(LDKWatch*)(val_ptr);
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)ChannelManagerReadArgs_get_tx_broadcaster(&this_ptr_conv)) | 1;
return ret_ret;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKBroadcasterInterface val_conv = *(LDKBroadcasterInterface*)(val_ptr);
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)ChannelManagerReadArgs_get_logger(&this_ptr_conv)) | 1;
return ret_ret;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKLogger val_conv = *(LDKLogger*)(val_ptr);
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUserConfig ret_var = ChannelManagerReadArgs_get_default_config(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUserConfig val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = UserConfig_clone(&val_conv);
ChannelManagerReadArgs_set_default_config(&this_ptr_conv, val_conv);
}
LDKUserConfig default_config_conv;
default_config_conv.inner = (void*)(default_config & (~1));
default_config_conv.is_owned = (default_config & 1) || (default_config == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(default_config_conv);
default_config_conv = UserConfig_clone(&default_config_conv);
LDKCVec_ChannelMonitorZ channel_monitors_constr;
channel_monitors_constr.datalen = *((uint32_t*)channel_monitors);
LDKChannelMonitor channel_monitors_conv_16_conv;
channel_monitors_conv_16_conv.inner = (void*)(channel_monitors_conv_16 & (~1));
channel_monitors_conv_16_conv.is_owned = (channel_monitors_conv_16 & 1) || (channel_monitors_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_monitors_conv_16_conv);
channel_monitors_constr.data[q] = channel_monitors_conv_16_conv;
}
LDKChannelManagerReadArgs ret_var = ChannelManagerReadArgs_new(keys_manager_conv, fee_estimator_conv, chain_monitor_conv, tx_broadcaster_conv, logger_conv, default_config_conv, channel_monitors_constr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelManagerReadArgs arg_conv;
arg_conv.inner = (void*)(arg & (~1));
arg_conv.is_owned = (arg & 1) || (arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
// Warning: we need a move here but no clone is available for LDKChannelManagerReadArgs
LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
*ret_conv = C2Tuple_BlockHashChannelManagerZ_read(ser_ref, arg_conv);
LDKDecodeError this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DecodeError_free(this_obj_conv);
}
+static inline uint64_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg) {
+ LDKDecodeError ret_var = DecodeError_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_DecodeError_clone_ptr(uint32_t arg) {
+ LDKDecodeError arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = DecodeError_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_DecodeError_clone(uint32_t orig) {
LDKDecodeError orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKDecodeError ret_var = DecodeError_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInit this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Init_free(this_obj_conv);
}
LDKInit this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInitFeatures ret_var = Init_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInit this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInitFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = InitFeatures_clone(&val_conv);
Init_set_features(&this_ptr_conv, val_conv);
}
LDKInitFeatures features_arg_conv;
features_arg_conv.inner = (void*)(features_arg & (~1));
features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
features_arg_conv = InitFeatures_clone(&features_arg_conv);
LDKInit ret_var = Init_new(features_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Init_clone_ptr(LDKInit *NONNULL_PTR arg) {
+ LDKInit ret_var = Init_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Init_clone_ptr(uint32_t arg) {
+ LDKInit arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Init_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Init_clone(uint32_t orig) {
LDKInit orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInit ret_var = Init_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKErrorMessage this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ErrorMessage_free(this_obj_conv);
}
LDKErrorMessage this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *ErrorMessage_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKErrorMessage this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKErrorMessage this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr ret_str = ErrorMessage_get_data(&this_ptr_conv);
jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
Str_free(ret_str);
LDKErrorMessage this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr val_conv = str_ref_to_owned_c(val);
ErrorMessage_set_data(&this_ptr_conv, val_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg) {
+ LDKErrorMessage ret_var = ErrorMessage_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ErrorMessage_clone_ptr(uint32_t arg) {
+ LDKErrorMessage arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ErrorMessage_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ErrorMessage_clone(uint32_t orig) {
LDKErrorMessage orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKErrorMessage ret_var = ErrorMessage_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPing this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Ping_free(this_obj_conv);
}
LDKPing this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = Ping_get_ponglen(&this_ptr_conv);
return ret_val;
}
LDKPing this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
Ping_set_ponglen(&this_ptr_conv, val);
}
LDKPing this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = Ping_get_byteslen(&this_ptr_conv);
return ret_val;
}
LDKPing this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
Ping_set_byteslen(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg) {
+ LDKPing ret_var = Ping_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Ping_clone_ptr(uint32_t arg) {
+ LDKPing arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Ping_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Ping_clone(uint32_t orig) {
LDKPing orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPing ret_var = Ping_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPong this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Pong_free(this_obj_conv);
}
LDKPong this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = Pong_get_byteslen(&this_ptr_conv);
return ret_val;
}
LDKPong this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
Pong_set_byteslen(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg) {
+ LDKPong ret_var = Pong_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Pong_clone_ptr(uint32_t arg) {
+ LDKPong arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Pong_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Pong_clone(uint32_t orig) {
LDKPong orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPong ret_var = Pong_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKOpenChannel this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
OpenChannel_free(this_obj_conv);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *OpenChannel_get_chain_hash(&this_ptr_conv), 32);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *OpenChannel_get_temporary_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_funding_satoshis(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_funding_satoshis(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_push_msat(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_push_msat(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_dust_limit_satoshis(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_channel_reserve_satoshis(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = OpenChannel_get_feerate_per_kw(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_feerate_per_kw(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = OpenChannel_get_to_self_delay(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_to_self_delay(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = OpenChannel_get_max_accepted_htlcs(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), OpenChannel_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), OpenChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), OpenChannel_get_payment_point(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), OpenChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), OpenChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), OpenChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_t ret_val = OpenChannel_get_channel_flags(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_channel_flags(&this_ptr_conv, val);
}
+static inline uint64_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg) {
+ LDKOpenChannel ret_var = OpenChannel_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_OpenChannel_clone_ptr(uint32_t arg) {
+ LDKOpenChannel arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = OpenChannel_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_OpenChannel_clone(uint32_t orig) {
LDKOpenChannel orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKOpenChannel ret_var = OpenChannel_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKAcceptChannel this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
AcceptChannel_free(this_obj_conv);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *AcceptChannel_get_temporary_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = AcceptChannel_get_dust_limit_satoshis(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = AcceptChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = AcceptChannel_get_channel_reserve_satoshis(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = AcceptChannel_get_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = AcceptChannel_get_minimum_depth(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_minimum_depth(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = AcceptChannel_get_to_self_delay(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_to_self_delay(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = AcceptChannel_get_max_accepted_htlcs(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), AcceptChannel_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), AcceptChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), AcceptChannel_get_payment_point(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), AcceptChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), AcceptChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), AcceptChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
AcceptChannel_set_first_per_commitment_point(&this_ptr_conv, val_ref);
}
+static inline uint64_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg) {
+ LDKAcceptChannel ret_var = AcceptChannel_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_AcceptChannel_clone_ptr(uint32_t arg) {
+ LDKAcceptChannel arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = AcceptChannel_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_AcceptChannel_clone(uint32_t orig) {
LDKAcceptChannel orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKAcceptChannel ret_var = AcceptChannel_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKFundingCreated this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
FundingCreated_free(this_obj_conv);
}
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *FundingCreated_get_temporary_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *FundingCreated_get_funding_txid(&this_ptr_conv), 32);
return ret_arr;
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = FundingCreated_get_funding_output_index(&this_ptr_conv);
return ret_val;
}
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
FundingCreated_set_funding_output_index(&this_ptr_conv, val);
}
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), FundingCreated_get_signature(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg) {
+ LDKFundingCreated ret_var = FundingCreated_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_FundingCreated_clone_ptr(uint32_t arg) {
+ LDKFundingCreated arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = FundingCreated_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_FundingCreated_clone(uint32_t orig) {
LDKFundingCreated orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKFundingCreated ret_var = FundingCreated_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKFundingSigned this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
FundingSigned_free(this_obj_conv);
}
LDKFundingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *FundingSigned_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKFundingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKFundingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), FundingSigned_get_signature(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKFundingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg) {
+ LDKFundingSigned ret_var = FundingSigned_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_FundingSigned_clone_ptr(uint32_t arg) {
+ LDKFundingSigned arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = FundingSigned_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_FundingSigned_clone(uint32_t orig) {
LDKFundingSigned orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKFundingSigned ret_var = FundingSigned_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKFundingLocked this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
FundingLocked_free(this_obj_conv);
}
LDKFundingLocked this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *FundingLocked_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKFundingLocked this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKFundingLocked this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), FundingLocked_get_next_per_commitment_point(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKFundingLocked this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t FundingLocked_clone_ptr(LDKFundingLocked *NONNULL_PTR arg) {
+ LDKFundingLocked ret_var = FundingLocked_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_FundingLocked_clone_ptr(uint32_t arg) {
+ LDKFundingLocked arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = FundingLocked_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_FundingLocked_clone(uint32_t orig) {
LDKFundingLocked orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKFundingLocked ret_var = FundingLocked_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKShutdown this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Shutdown_free(this_obj_conv);
}
LDKShutdown this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *Shutdown_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKShutdown this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKShutdown this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKu8slice ret_var = Shutdown_get_scriptpubkey(&this_ptr_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKShutdown this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u8Z val_ref;
val_ref.datalen = *((uint32_t*)val);
val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg) {
+ LDKShutdown ret_var = Shutdown_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Shutdown_clone_ptr(uint32_t arg) {
+ LDKShutdown arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Shutdown_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Shutdown_clone(uint32_t orig) {
LDKShutdown orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKShutdown ret_var = Shutdown_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingSignedFeeRange this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ClosingSignedFeeRange_free(this_obj_conv);
}
LDKClosingSignedFeeRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ClosingSignedFeeRange_get_min_fee_satoshis(&this_ptr_conv);
return ret_val;
}
LDKClosingSignedFeeRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ClosingSignedFeeRange_set_min_fee_satoshis(&this_ptr_conv, val);
}
LDKClosingSignedFeeRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ClosingSignedFeeRange_get_max_fee_satoshis(&this_ptr_conv);
return ret_val;
}
LDKClosingSignedFeeRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ClosingSignedFeeRange_set_max_fee_satoshis(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg) {
+ LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ClosingSignedFeeRange_clone_ptr(uint32_t arg) {
+ LDKClosingSignedFeeRange arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ClosingSignedFeeRange_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ClosingSignedFeeRange_clone(uint32_t orig) {
LDKClosingSignedFeeRange orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingSigned this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ClosingSigned_free(this_obj_conv);
}
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *ClosingSigned_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ClosingSigned_get_fee_satoshis(&this_ptr_conv);
return ret_val;
}
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ClosingSigned_set_fee_satoshis(&this_ptr_conv, val);
}
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ClosingSigned_get_signature(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKClosingSignedFeeRange ret_var = ClosingSigned_get_fee_range(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKClosingSignedFeeRange val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ClosingSignedFeeRange_clone(&val_conv);
ClosingSigned_set_fee_range(&this_ptr_conv, val_conv);
}
LDKClosingSignedFeeRange fee_range_arg_conv;
fee_range_arg_conv.inner = (void*)(fee_range_arg & (~1));
fee_range_arg_conv.is_owned = (fee_range_arg & 1) || (fee_range_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(fee_range_arg_conv);
fee_range_arg_conv = ClosingSignedFeeRange_clone(&fee_range_arg_conv);
LDKClosingSigned ret_var = ClosingSigned_new(channel_id_arg_ref, fee_satoshis_arg, signature_arg_ref, fee_range_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg) {
+ LDKClosingSigned ret_var = ClosingSigned_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ClosingSigned_clone_ptr(uint32_t arg) {
+ LDKClosingSigned arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ClosingSigned_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ClosingSigned_clone(uint32_t orig) {
LDKClosingSigned orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKClosingSigned ret_var = ClosingSigned_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUpdateAddHTLC this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UpdateAddHTLC_free(this_obj_conv);
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *UpdateAddHTLC_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UpdateAddHTLC_get_htlc_id(&this_ptr_conv);
return ret_val;
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateAddHTLC_set_htlc_id(&this_ptr_conv, val);
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UpdateAddHTLC_get_amount_msat(&this_ptr_conv);
return ret_val;
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateAddHTLC_set_amount_msat(&this_ptr_conv, val);
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *UpdateAddHTLC_get_payment_hash(&this_ptr_conv), 32);
return ret_arr;
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UpdateAddHTLC_get_cltv_expiry(&this_ptr_conv);
return ret_val;
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateAddHTLC_set_cltv_expiry(&this_ptr_conv, val);
}
+static inline uint64_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg) {
+ LDKUpdateAddHTLC ret_var = UpdateAddHTLC_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_UpdateAddHTLC_clone_ptr(uint32_t arg) {
+ LDKUpdateAddHTLC arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UpdateAddHTLC_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_UpdateAddHTLC_clone(uint32_t orig) {
LDKUpdateAddHTLC orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUpdateAddHTLC ret_var = UpdateAddHTLC_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUpdateFulfillHTLC this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UpdateFulfillHTLC_free(this_obj_conv);
}
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *UpdateFulfillHTLC_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UpdateFulfillHTLC_get_htlc_id(&this_ptr_conv);
return ret_val;
}
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateFulfillHTLC_set_htlc_id(&this_ptr_conv, val);
}
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *UpdateFulfillHTLC_get_payment_preimage(&this_ptr_conv), 32);
return ret_arr;
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg) {
+ LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_UpdateFulfillHTLC_clone_ptr(uint32_t arg) {
+ LDKUpdateFulfillHTLC arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UpdateFulfillHTLC_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_UpdateFulfillHTLC_clone(uint32_t orig) {
LDKUpdateFulfillHTLC orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUpdateFailHTLC this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UpdateFailHTLC_free(this_obj_conv);
}
LDKUpdateFailHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *UpdateFailHTLC_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKUpdateFailHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKUpdateFailHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UpdateFailHTLC_get_htlc_id(&this_ptr_conv);
return ret_val;
}
LDKUpdateFailHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateFailHTLC_set_htlc_id(&this_ptr_conv, val);
}
+static inline uint64_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg) {
+ LDKUpdateFailHTLC ret_var = UpdateFailHTLC_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_UpdateFailHTLC_clone_ptr(uint32_t arg) {
+ LDKUpdateFailHTLC arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UpdateFailHTLC_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_UpdateFailHTLC_clone(uint32_t orig) {
LDKUpdateFailHTLC orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUpdateFailHTLC ret_var = UpdateFailHTLC_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUpdateFailMalformedHTLC this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UpdateFailMalformedHTLC_free(this_obj_conv);
}
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *UpdateFailMalformedHTLC_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UpdateFailMalformedHTLC_get_htlc_id(&this_ptr_conv);
return ret_val;
}
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateFailMalformedHTLC_set_htlc_id(&this_ptr_conv, val);
}
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = UpdateFailMalformedHTLC_get_failure_code(&this_ptr_conv);
return ret_val;
}
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateFailMalformedHTLC_set_failure_code(&this_ptr_conv, val);
}
+static inline uint64_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg) {
+ LDKUpdateFailMalformedHTLC ret_var = UpdateFailMalformedHTLC_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_UpdateFailMalformedHTLC_clone_ptr(uint32_t arg) {
+ LDKUpdateFailMalformedHTLC arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UpdateFailMalformedHTLC_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_UpdateFailMalformedHTLC_clone(uint32_t orig) {
LDKUpdateFailMalformedHTLC orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUpdateFailMalformedHTLC ret_var = UpdateFailMalformedHTLC_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentSigned this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
CommitmentSigned_free(this_obj_conv);
}
LDKCommitmentSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *CommitmentSigned_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKCommitmentSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKCommitmentSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), CommitmentSigned_get_signature(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKCommitmentSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
LDKCommitmentSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_SignatureZ val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg) {
+ LDKCommitmentSigned ret_var = CommitmentSigned_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_CommitmentSigned_clone_ptr(uint32_t arg) {
+ LDKCommitmentSigned arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = CommitmentSigned_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CommitmentSigned_clone(uint32_t orig) {
LDKCommitmentSigned orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKCommitmentSigned ret_var = CommitmentSigned_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRevokeAndACK this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RevokeAndACK_free(this_obj_conv);
}
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *RevokeAndACK_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *RevokeAndACK_get_per_commitment_secret(&this_ptr_conv), 32);
return ret_arr;
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), RevokeAndACK_get_next_per_commitment_point(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg) {
+ LDKRevokeAndACK ret_var = RevokeAndACK_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_RevokeAndACK_clone_ptr(uint32_t arg) {
+ LDKRevokeAndACK arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RevokeAndACK_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_RevokeAndACK_clone(uint32_t orig) {
LDKRevokeAndACK orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRevokeAndACK ret_var = RevokeAndACK_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUpdateFee this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UpdateFee_free(this_obj_conv);
}
LDKUpdateFee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *UpdateFee_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKUpdateFee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKUpdateFee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UpdateFee_get_feerate_per_kw(&this_ptr_conv);
return ret_val;
}
LDKUpdateFee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateFee_set_feerate_per_kw(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg) {
+ LDKUpdateFee ret_var = UpdateFee_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_UpdateFee_clone_ptr(uint32_t arg) {
+ LDKUpdateFee arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UpdateFee_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_UpdateFee_clone(uint32_t orig) {
LDKUpdateFee orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUpdateFee ret_var = UpdateFee_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDataLossProtect this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DataLossProtect_free(this_obj_conv);
}
LDKDataLossProtect this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *DataLossProtect_get_your_last_per_commitment_secret(&this_ptr_conv), 32);
return ret_arr;
LDKDataLossProtect this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKDataLossProtect this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), DataLossProtect_get_my_current_per_commitment_point(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKDataLossProtect this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg) {
+ LDKDataLossProtect ret_var = DataLossProtect_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_DataLossProtect_clone_ptr(uint32_t arg) {
+ LDKDataLossProtect arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = DataLossProtect_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_DataLossProtect_clone(uint32_t orig) {
LDKDataLossProtect orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKDataLossProtect ret_var = DataLossProtect_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelReestablish this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelReestablish_free(this_obj_conv);
}
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *ChannelReestablish_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelReestablish_get_next_local_commitment_number(&this_ptr_conv);
return ret_val;
}
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelReestablish_set_next_local_commitment_number(&this_ptr_conv, val);
}
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelReestablish_get_next_remote_commitment_number(&this_ptr_conv);
return ret_val;
}
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelReestablish_set_next_remote_commitment_number(&this_ptr_conv, val);
}
+static inline uint64_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg) {
+ LDKChannelReestablish ret_var = ChannelReestablish_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelReestablish_clone_ptr(uint32_t arg) {
+ LDKChannelReestablish arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelReestablish_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelReestablish_clone(uint32_t orig) {
LDKChannelReestablish orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelReestablish ret_var = ChannelReestablish_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKAnnouncementSignatures this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
AnnouncementSignatures_free(this_obj_conv);
}
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *AnnouncementSignatures_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = AnnouncementSignatures_get_short_channel_id(&this_ptr_conv);
return ret_val;
}
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AnnouncementSignatures_set_short_channel_id(&this_ptr_conv, val);
}
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), AnnouncementSignatures_get_node_signature(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), AnnouncementSignatures_get_bitcoin_signature(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg) {
+ LDKAnnouncementSignatures ret_var = AnnouncementSignatures_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_AnnouncementSignatures_clone_ptr(uint32_t arg) {
+ LDKAnnouncementSignatures arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = AnnouncementSignatures_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_AnnouncementSignatures_clone(uint32_t orig) {
LDKAnnouncementSignatures orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKAnnouncementSignatures ret_var = AnnouncementSignatures_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
NetAddress_free(this_ptr_conv);
}
+static inline uint64_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg) {
+ LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
+ *ret_copy = NetAddress_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_NetAddress_clone_ptr(uint32_t arg) {
+ LDKNetAddress* arg_conv = (LDKNetAddress*)arg;
+ int64_t ret_val = NetAddress_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_NetAddress_clone(uint32_t orig) {
LDKNetAddress* orig_conv = (LDKNetAddress*)orig;
LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
LDKUnsignedNodeAnnouncement this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UnsignedNodeAnnouncement_free(this_obj_conv);
}
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures ret_var = UnsignedNodeAnnouncement_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeFeatures_clone(&val_conv);
UnsignedNodeAnnouncement_set_features(&this_ptr_conv, val_conv);
}
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UnsignedNodeAnnouncement_get_timestamp(&this_ptr_conv);
return ret_val;
}
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedNodeAnnouncement_set_timestamp(&this_ptr_conv, val);
}
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), UnsignedNodeAnnouncement_get_node_id(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(3, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *UnsignedNodeAnnouncement_get_rgb(&this_ptr_conv), 3);
return ret_arr;
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThreeBytes val_ref;
CHECK(*((uint32_t*)val) == 3);
memcpy(val_ref.data, (uint8_t*)(val + 4), 3);
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *UnsignedNodeAnnouncement_get_alias(&this_ptr_conv), 32);
return ret_arr;
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_NetAddressZ val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
UnsignedNodeAnnouncement_set_addresses(&this_ptr_conv, val_constr);
}
+static inline uint64_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg) {
+ LDKUnsignedNodeAnnouncement ret_var = UnsignedNodeAnnouncement_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_UnsignedNodeAnnouncement_clone_ptr(uint32_t arg) {
+ LDKUnsignedNodeAnnouncement arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UnsignedNodeAnnouncement_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_UnsignedNodeAnnouncement_clone(uint32_t orig) {
LDKUnsignedNodeAnnouncement orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUnsignedNodeAnnouncement ret_var = UnsignedNodeAnnouncement_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeAnnouncement this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NodeAnnouncement_free(this_obj_conv);
}
LDKNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), NodeAnnouncement_get_signature(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
LDKNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedNodeAnnouncement ret_var = NodeAnnouncement_get_contents(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedNodeAnnouncement val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = UnsignedNodeAnnouncement_clone(&val_conv);
NodeAnnouncement_set_contents(&this_ptr_conv, val_conv);
}
LDKUnsignedNodeAnnouncement contents_arg_conv;
contents_arg_conv.inner = (void*)(contents_arg & (~1));
contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
contents_arg_conv = UnsignedNodeAnnouncement_clone(&contents_arg_conv);
LDKNodeAnnouncement ret_var = NodeAnnouncement_new(signature_arg_ref, contents_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg) {
+ LDKNodeAnnouncement ret_var = NodeAnnouncement_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_NodeAnnouncement_clone_ptr(uint32_t arg) {
+ LDKNodeAnnouncement arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NodeAnnouncement_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncement_clone(uint32_t orig) {
LDKNodeAnnouncement orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNodeAnnouncement ret_var = NodeAnnouncement_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUnsignedChannelAnnouncement this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UnsignedChannelAnnouncement_free(this_obj_conv);
}
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures ret_var = UnsignedChannelAnnouncement_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelFeatures_clone(&val_conv);
UnsignedChannelAnnouncement_set_features(&this_ptr_conv, val_conv);
}
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *UnsignedChannelAnnouncement_get_chain_hash(&this_ptr_conv), 32);
return ret_arr;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UnsignedChannelAnnouncement_get_short_channel_id(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelAnnouncement_set_short_channel_id(&this_ptr_conv, val);
}
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), UnsignedChannelAnnouncement_get_node_id_1(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), UnsignedChannelAnnouncement_get_node_id_2(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), UnsignedChannelAnnouncement_get_bitcoin_key_1(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), UnsignedChannelAnnouncement_get_bitcoin_key_2(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
UnsignedChannelAnnouncement_set_bitcoin_key_2(&this_ptr_conv, val_ref);
}
+static inline uint64_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg) {
+ LDKUnsignedChannelAnnouncement ret_var = UnsignedChannelAnnouncement_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_UnsignedChannelAnnouncement_clone_ptr(uint32_t arg) {
+ LDKUnsignedChannelAnnouncement arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UnsignedChannelAnnouncement_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_UnsignedChannelAnnouncement_clone(uint32_t orig) {
LDKUnsignedChannelAnnouncement orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUnsignedChannelAnnouncement ret_var = UnsignedChannelAnnouncement_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelAnnouncement this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelAnnouncement_free(this_obj_conv);
}
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelAnnouncement_get_node_signature_1(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelAnnouncement_get_node_signature_2(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelAnnouncement_get_bitcoin_signature_1(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelAnnouncement_get_bitcoin_signature_2(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedChannelAnnouncement ret_var = ChannelAnnouncement_get_contents(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedChannelAnnouncement val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = UnsignedChannelAnnouncement_clone(&val_conv);
ChannelAnnouncement_set_contents(&this_ptr_conv, val_conv);
}
LDKUnsignedChannelAnnouncement contents_arg_conv;
contents_arg_conv.inner = (void*)(contents_arg & (~1));
contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
contents_arg_conv = UnsignedChannelAnnouncement_clone(&contents_arg_conv);
LDKChannelAnnouncement ret_var = ChannelAnnouncement_new(node_signature_1_arg_ref, node_signature_2_arg_ref, bitcoin_signature_1_arg_ref, bitcoin_signature_2_arg_ref, contents_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg) {
+ LDKChannelAnnouncement ret_var = ChannelAnnouncement_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelAnnouncement_clone_ptr(uint32_t arg) {
+ LDKChannelAnnouncement arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelAnnouncement_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelAnnouncement_clone(uint32_t orig) {
LDKChannelAnnouncement orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelAnnouncement ret_var = ChannelAnnouncement_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUnsignedChannelUpdate this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UnsignedChannelUpdate_free(this_obj_conv);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *UnsignedChannelUpdate_get_chain_hash(&this_ptr_conv), 32);
return ret_arr;
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UnsignedChannelUpdate_get_short_channel_id(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_short_channel_id(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UnsignedChannelUpdate_get_timestamp(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_timestamp(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_t ret_val = UnsignedChannelUpdate_get_flags(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_flags(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = UnsignedChannelUpdate_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UnsignedChannelUpdate_get_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_htlc_minimum_msat(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UnsignedChannelUpdate_get_fee_base_msat(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_fee_base_msat(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UnsignedChannelUpdate_get_fee_proportional_millionths(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_fee_proportional_millionths(&this_ptr_conv, val);
}
+static inline uint64_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg) {
+ LDKUnsignedChannelUpdate ret_var = UnsignedChannelUpdate_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_clone_ptr(uint32_t arg) {
+ LDKUnsignedChannelUpdate arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UnsignedChannelUpdate_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_clone(uint32_t orig) {
LDKUnsignedChannelUpdate orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUnsignedChannelUpdate ret_var = UnsignedChannelUpdate_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelUpdate this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelUpdate_free(this_obj_conv);
}
LDKChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelUpdate_get_signature(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
LDKChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedChannelUpdate ret_var = ChannelUpdate_get_contents(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedChannelUpdate val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = UnsignedChannelUpdate_clone(&val_conv);
ChannelUpdate_set_contents(&this_ptr_conv, val_conv);
}
LDKUnsignedChannelUpdate contents_arg_conv;
contents_arg_conv.inner = (void*)(contents_arg & (~1));
contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
contents_arg_conv = UnsignedChannelUpdate_clone(&contents_arg_conv);
LDKChannelUpdate ret_var = ChannelUpdate_new(signature_arg_ref, contents_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg) {
+ LDKChannelUpdate ret_var = ChannelUpdate_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelUpdate_clone_ptr(uint32_t arg) {
+ LDKChannelUpdate arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelUpdate_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelUpdate_clone(uint32_t orig) {
LDKChannelUpdate orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelUpdate ret_var = ChannelUpdate_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKQueryChannelRange this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
QueryChannelRange_free(this_obj_conv);
}
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *QueryChannelRange_get_chain_hash(&this_ptr_conv), 32);
return ret_arr;
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = QueryChannelRange_get_first_blocknum(&this_ptr_conv);
return ret_val;
}
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
QueryChannelRange_set_first_blocknum(&this_ptr_conv, val);
}
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = QueryChannelRange_get_number_of_blocks(&this_ptr_conv);
return ret_val;
}
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
QueryChannelRange_set_number_of_blocks(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg) {
+ LDKQueryChannelRange ret_var = QueryChannelRange_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_QueryChannelRange_clone_ptr(uint32_t arg) {
+ LDKQueryChannelRange arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = QueryChannelRange_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_QueryChannelRange_clone(uint32_t orig) {
LDKQueryChannelRange orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKQueryChannelRange ret_var = QueryChannelRange_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKReplyChannelRange this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ReplyChannelRange_free(this_obj_conv);
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *ReplyChannelRange_get_chain_hash(&this_ptr_conv), 32);
return ret_arr;
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ReplyChannelRange_get_first_blocknum(&this_ptr_conv);
return ret_val;
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ReplyChannelRange_set_first_blocknum(&this_ptr_conv, val);
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ReplyChannelRange_get_number_of_blocks(&this_ptr_conv);
return ret_val;
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ReplyChannelRange_set_number_of_blocks(&this_ptr_conv, val);
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ReplyChannelRange_get_sync_complete(&this_ptr_conv);
return ret_val;
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ReplyChannelRange_set_sync_complete(&this_ptr_conv, val);
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u64Z val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg) {
+ LDKReplyChannelRange ret_var = ReplyChannelRange_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ReplyChannelRange_clone_ptr(uint32_t arg) {
+ LDKReplyChannelRange arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ReplyChannelRange_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ReplyChannelRange_clone(uint32_t orig) {
LDKReplyChannelRange orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKReplyChannelRange ret_var = ReplyChannelRange_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKQueryShortChannelIds this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
QueryShortChannelIds_free(this_obj_conv);
}
LDKQueryShortChannelIds this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *QueryShortChannelIds_get_chain_hash(&this_ptr_conv), 32);
return ret_arr;
LDKQueryShortChannelIds this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKQueryShortChannelIds this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u64Z val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg) {
+ LDKQueryShortChannelIds ret_var = QueryShortChannelIds_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_QueryShortChannelIds_clone_ptr(uint32_t arg) {
+ LDKQueryShortChannelIds arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = QueryShortChannelIds_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_QueryShortChannelIds_clone(uint32_t orig) {
LDKQueryShortChannelIds orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKQueryShortChannelIds ret_var = QueryShortChannelIds_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKReplyShortChannelIdsEnd this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ReplyShortChannelIdsEnd_free(this_obj_conv);
}
LDKReplyShortChannelIdsEnd this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *ReplyShortChannelIdsEnd_get_chain_hash(&this_ptr_conv), 32);
return ret_arr;
LDKReplyShortChannelIdsEnd this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKReplyShortChannelIdsEnd this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ReplyShortChannelIdsEnd_get_full_information(&this_ptr_conv);
return ret_val;
}
LDKReplyShortChannelIdsEnd this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ReplyShortChannelIdsEnd_set_full_information(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg) {
+ LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ReplyShortChannelIdsEnd_clone_ptr(uint32_t arg) {
+ LDKReplyShortChannelIdsEnd arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ReplyShortChannelIdsEnd_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ReplyShortChannelIdsEnd_clone(uint32_t orig) {
LDKReplyShortChannelIdsEnd orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKGossipTimestampFilter this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
GossipTimestampFilter_free(this_obj_conv);
}
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *GossipTimestampFilter_get_chain_hash(&this_ptr_conv), 32);
return ret_arr;
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = GossipTimestampFilter_get_first_timestamp(&this_ptr_conv);
return ret_val;
}
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
GossipTimestampFilter_set_first_timestamp(&this_ptr_conv, val);
}
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = GossipTimestampFilter_get_timestamp_range(&this_ptr_conv);
return ret_val;
}
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
GossipTimestampFilter_set_timestamp_range(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg) {
+ LDKGossipTimestampFilter ret_var = GossipTimestampFilter_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_GossipTimestampFilter_clone_ptr(uint32_t arg) {
+ LDKGossipTimestampFilter arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = GossipTimestampFilter_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_GossipTimestampFilter_clone(uint32_t orig) {
LDKGossipTimestampFilter orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKGossipTimestampFilter ret_var = GossipTimestampFilter_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
ErrorAction_free(this_ptr_conv);
}
+static inline uint64_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg) {
+ LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
+ *ret_copy = ErrorAction_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ErrorAction_clone_ptr(uint32_t arg) {
+ LDKErrorAction* arg_conv = (LDKErrorAction*)arg;
+ int64_t ret_val = ErrorAction_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ErrorAction_clone(uint32_t orig) {
LDKErrorAction* orig_conv = (LDKErrorAction*)orig;
LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
LDKErrorMessage msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ErrorMessage_clone(&msg_conv);
LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
*ret_copy = ErrorAction_disconnect_peer(msg_conv);
LDKErrorMessage msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ErrorMessage_clone(&msg_conv);
LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
*ret_copy = ErrorAction_send_error_message(msg_conv);
LDKLightningError this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
LightningError_free(this_obj_conv);
}
LDKLightningError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr ret_str = LightningError_get_err(&this_ptr_conv);
jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
Str_free(ret_str);
LDKLightningError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr val_conv = str_ref_to_owned_c(val);
LightningError_set_err(&this_ptr_conv, val_conv);
}
LDKLightningError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
*ret_copy = LightningError_get_action(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKLightningError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKErrorAction val_conv = *(LDKErrorAction*)(val_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg) {
+ LDKLightningError ret_var = LightningError_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_LightningError_clone_ptr(uint32_t arg) {
+ LDKLightningError arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = LightningError_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_LightningError_clone(uint32_t orig) {
LDKLightningError orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKLightningError ret_var = LightningError_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentUpdate this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
CommitmentUpdate_free(this_obj_conv);
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateAddHTLCZ ret_var = CommitmentUpdate_get_update_add_htlcs(&this_ptr_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_15_ref = 0;
CHECK((((uint64_t)ret_conv_15_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_15_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_15_var);
ret_conv_15_ref = (uint64_t)ret_conv_15_var.inner;
if (ret_conv_15_var.is_owned) {
ret_conv_15_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateAddHTLCZ val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
LDKUpdateAddHTLC val_conv_15_conv;
val_conv_15_conv.inner = (void*)(val_conv_15 & (~1));
val_conv_15_conv.is_owned = (val_conv_15 & 1) || (val_conv_15 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_15_conv);
val_conv_15_conv = UpdateAddHTLC_clone(&val_conv_15_conv);
val_constr.data[p] = val_conv_15_conv;
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFulfillHTLCZ ret_var = CommitmentUpdate_get_update_fulfill_htlcs(&this_ptr_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_19_ref = 0;
CHECK((((uint64_t)ret_conv_19_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_19_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_19_var);
ret_conv_19_ref = (uint64_t)ret_conv_19_var.inner;
if (ret_conv_19_var.is_owned) {
ret_conv_19_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFulfillHTLCZ val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
LDKUpdateFulfillHTLC val_conv_19_conv;
val_conv_19_conv.inner = (void*)(val_conv_19 & (~1));
val_conv_19_conv.is_owned = (val_conv_19 & 1) || (val_conv_19 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_19_conv);
val_conv_19_conv = UpdateFulfillHTLC_clone(&val_conv_19_conv);
val_constr.data[t] = val_conv_19_conv;
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFailHTLCZ ret_var = CommitmentUpdate_get_update_fail_htlcs(&this_ptr_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_16_ref = 0;
CHECK((((uint64_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
ret_conv_16_ref = (uint64_t)ret_conv_16_var.inner;
if (ret_conv_16_var.is_owned) {
ret_conv_16_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFailHTLCZ val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
LDKUpdateFailHTLC val_conv_16_conv;
val_conv_16_conv.inner = (void*)(val_conv_16 & (~1));
val_conv_16_conv.is_owned = (val_conv_16 & 1) || (val_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_16_conv);
val_conv_16_conv = UpdateFailHTLC_clone(&val_conv_16_conv);
val_constr.data[q] = val_conv_16_conv;
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFailMalformedHTLCZ ret_var = CommitmentUpdate_get_update_fail_malformed_htlcs(&this_ptr_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_25_ref = 0;
CHECK((((uint64_t)ret_conv_25_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_25_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_25_var);
ret_conv_25_ref = (uint64_t)ret_conv_25_var.inner;
if (ret_conv_25_var.is_owned) {
ret_conv_25_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFailMalformedHTLCZ val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
LDKUpdateFailMalformedHTLC val_conv_25_conv;
val_conv_25_conv.inner = (void*)(val_conv_25 & (~1));
val_conv_25_conv.is_owned = (val_conv_25 & 1) || (val_conv_25 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_25_conv);
val_conv_25_conv = UpdateFailMalformedHTLC_clone(&val_conv_25_conv);
val_constr.data[z] = val_conv_25_conv;
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUpdateFee ret_var = CommitmentUpdate_get_update_fee(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUpdateFee val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = UpdateFee_clone(&val_conv);
CommitmentUpdate_set_update_fee(&this_ptr_conv, val_conv);
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCommitmentSigned ret_var = CommitmentUpdate_get_commitment_signed(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCommitmentSigned val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = CommitmentSigned_clone(&val_conv);
CommitmentUpdate_set_commitment_signed(&this_ptr_conv, val_conv);
}
LDKUpdateAddHTLC update_add_htlcs_arg_conv_15_conv;
update_add_htlcs_arg_conv_15_conv.inner = (void*)(update_add_htlcs_arg_conv_15 & (~1));
update_add_htlcs_arg_conv_15_conv.is_owned = (update_add_htlcs_arg_conv_15 & 1) || (update_add_htlcs_arg_conv_15 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_add_htlcs_arg_conv_15_conv);
update_add_htlcs_arg_conv_15_conv = UpdateAddHTLC_clone(&update_add_htlcs_arg_conv_15_conv);
update_add_htlcs_arg_constr.data[p] = update_add_htlcs_arg_conv_15_conv;
}
LDKUpdateFulfillHTLC update_fulfill_htlcs_arg_conv_19_conv;
update_fulfill_htlcs_arg_conv_19_conv.inner = (void*)(update_fulfill_htlcs_arg_conv_19 & (~1));
update_fulfill_htlcs_arg_conv_19_conv.is_owned = (update_fulfill_htlcs_arg_conv_19 & 1) || (update_fulfill_htlcs_arg_conv_19 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fulfill_htlcs_arg_conv_19_conv);
update_fulfill_htlcs_arg_conv_19_conv = UpdateFulfillHTLC_clone(&update_fulfill_htlcs_arg_conv_19_conv);
update_fulfill_htlcs_arg_constr.data[t] = update_fulfill_htlcs_arg_conv_19_conv;
}
LDKUpdateFailHTLC update_fail_htlcs_arg_conv_16_conv;
update_fail_htlcs_arg_conv_16_conv.inner = (void*)(update_fail_htlcs_arg_conv_16 & (~1));
update_fail_htlcs_arg_conv_16_conv.is_owned = (update_fail_htlcs_arg_conv_16 & 1) || (update_fail_htlcs_arg_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fail_htlcs_arg_conv_16_conv);
update_fail_htlcs_arg_conv_16_conv = UpdateFailHTLC_clone(&update_fail_htlcs_arg_conv_16_conv);
update_fail_htlcs_arg_constr.data[q] = update_fail_htlcs_arg_conv_16_conv;
}
LDKUpdateFailMalformedHTLC update_fail_malformed_htlcs_arg_conv_25_conv;
update_fail_malformed_htlcs_arg_conv_25_conv.inner = (void*)(update_fail_malformed_htlcs_arg_conv_25 & (~1));
update_fail_malformed_htlcs_arg_conv_25_conv.is_owned = (update_fail_malformed_htlcs_arg_conv_25 & 1) || (update_fail_malformed_htlcs_arg_conv_25 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fail_malformed_htlcs_arg_conv_25_conv);
update_fail_malformed_htlcs_arg_conv_25_conv = UpdateFailMalformedHTLC_clone(&update_fail_malformed_htlcs_arg_conv_25_conv);
update_fail_malformed_htlcs_arg_constr.data[z] = update_fail_malformed_htlcs_arg_conv_25_conv;
}
LDKUpdateFee update_fee_arg_conv;
update_fee_arg_conv.inner = (void*)(update_fee_arg & (~1));
update_fee_arg_conv.is_owned = (update_fee_arg & 1) || (update_fee_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fee_arg_conv);
update_fee_arg_conv = UpdateFee_clone(&update_fee_arg_conv);
LDKCommitmentSigned commitment_signed_arg_conv;
commitment_signed_arg_conv.inner = (void*)(commitment_signed_arg & (~1));
commitment_signed_arg_conv.is_owned = (commitment_signed_arg & 1) || (commitment_signed_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_signed_arg_conv);
commitment_signed_arg_conv = CommitmentSigned_clone(&commitment_signed_arg_conv);
LDKCommitmentUpdate ret_var = CommitmentUpdate_new(update_add_htlcs_arg_constr, update_fulfill_htlcs_arg_constr, update_fail_htlcs_arg_constr, update_fail_malformed_htlcs_arg_constr, update_fee_arg_conv, commitment_signed_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg) {
+ LDKCommitmentUpdate ret_var = CommitmentUpdate_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_CommitmentUpdate_clone_ptr(uint32_t arg) {
+ LDKCommitmentUpdate arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = CommitmentUpdate_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CommitmentUpdate_clone(uint32_t orig) {
LDKCommitmentUpdate orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKCommitmentUpdate ret_var = CommitmentUpdate_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKAcceptChannel obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = AcceptChannel_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKAnnouncementSignatures obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = AnnouncementSignatures_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKChannelReestablish obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelReestablish_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKClosingSigned obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ClosingSigned_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKClosingSignedFeeRange obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ClosingSignedFeeRange_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKCommitmentSigned obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = CommitmentSigned_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKFundingCreated obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = FundingCreated_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKFundingSigned obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = FundingSigned_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKFundingLocked obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = FundingLocked_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKInit obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Init_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKOpenChannel obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = OpenChannel_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKRevokeAndACK obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RevokeAndACK_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKShutdown obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Shutdown_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKUpdateFailHTLC obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UpdateFailHTLC_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKUpdateFailMalformedHTLC obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UpdateFailMalformedHTLC_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKUpdateFee obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UpdateFee_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKUpdateFulfillHTLC obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UpdateFulfillHTLC_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKUpdateAddHTLC obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UpdateAddHTLC_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKPing obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Ping_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKPong obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Pong_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKUnsignedChannelAnnouncement obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UnsignedChannelAnnouncement_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKChannelAnnouncement obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelAnnouncement_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKUnsignedChannelUpdate obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UnsignedChannelUpdate_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKChannelUpdate obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelUpdate_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKErrorMessage obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ErrorMessage_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKUnsignedNodeAnnouncement obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UnsignedNodeAnnouncement_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKNodeAnnouncement obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NodeAnnouncement_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKQueryShortChannelIds obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = QueryShortChannelIds_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKReplyShortChannelIdsEnd obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ReplyShortChannelIdsEnd_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKQueryChannelRange this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int32_t ret_val = QueryChannelRange_end_blocknum(&this_arg_conv);
return ret_val;
}
LDKQueryChannelRange obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = QueryChannelRange_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKReplyChannelRange obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ReplyChannelRange_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKGossipTimestampFilter obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = GossipTimestampFilter_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKIgnoringMessageHandler this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
IgnoringMessageHandler_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKIgnoringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
*ret_ret = IgnoringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKIgnoringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRoutingMessageHandler* ret_ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
*ret_ret = IgnoringMessageHandler_as_RoutingMessageHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKIgnoringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCustomMessageReader* ret_ret = MALLOC(sizeof(LDKCustomMessageReader), "LDKCustomMessageReader");
*ret_ret = IgnoringMessageHandler_as_CustomMessageReader(&this_arg_conv);
return (uint64_t)ret_ret;
LDKIgnoringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCustomMessageHandler* ret_ret = MALLOC(sizeof(LDKCustomMessageHandler), "LDKCustomMessageHandler");
*ret_ret = IgnoringMessageHandler_as_CustomMessageHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKErroringMessageHandler this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ErroringMessageHandler_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKErroringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
*ret_ret = ErroringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKErroringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelMessageHandler* ret_ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
*ret_ret = ErroringMessageHandler_as_ChannelMessageHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKMessageHandler this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
MessageHandler_free(this_obj_conv);
}
LDKMessageHandler this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)MessageHandler_get_chan_handler(&this_ptr_conv)) | 1;
return ret_ret;
LDKMessageHandler this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKChannelMessageHandler val_conv = *(LDKChannelMessageHandler*)(val_ptr);
LDKMessageHandler this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)MessageHandler_get_route_handler(&this_ptr_conv)) | 1;
return ret_ret;
LDKMessageHandler this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKRoutingMessageHandler val_conv = *(LDKRoutingMessageHandler*)(val_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg) {
+ LDKSocketDescriptor* ret_ret = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
+ *ret_ret = SocketDescriptor_clone(arg);
+ return (uint64_t)ret_ret;
+}
+int64_t __attribute__((visibility("default"))) TS_SocketDescriptor_clone_ptr(uint32_t arg) {
+ void* arg_ptr = (void*)(((uint64_t)arg) & ~1);
+ if (!(arg & 1)) { CHECK_ACCESS(arg_ptr); }
+ LDKSocketDescriptor* arg_conv = (LDKSocketDescriptor*)arg_ptr;
+ int64_t ret_val = SocketDescriptor_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_SocketDescriptor_clone(uint32_t orig) {
void* orig_ptr = (void*)(((uint64_t)orig) & ~1);
if (!(orig & 1)) { CHECK_ACCESS(orig_ptr); }
LDKPeerHandleError this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
PeerHandleError_free(this_obj_conv);
}
LDKPeerHandleError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = PeerHandleError_get_no_connection_possible(&this_ptr_conv);
return ret_val;
}
LDKPeerHandleError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
PeerHandleError_set_no_connection_possible(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg) {
+ LDKPeerHandleError ret_var = PeerHandleError_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_PeerHandleError_clone_ptr(uint32_t arg) {
+ LDKPeerHandleError arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = PeerHandleError_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_PeerHandleError_clone(uint32_t orig) {
LDKPeerHandleError orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPeerHandleError ret_var = PeerHandleError_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPeerManager this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
PeerManager_free(this_obj_conv);
}
LDKMessageHandler message_handler_conv;
message_handler_conv.inner = (void*)(message_handler & (~1));
message_handler_conv.is_owned = (message_handler & 1) || (message_handler == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(message_handler_conv);
// Warning: we need a move here but no clone is available for LDKMessageHandler
LDKSecretKey our_node_secret_ref;
CHECK(*((uint32_t*)our_node_secret) == 32);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_PublicKeyZ ret_var = PeerManager_get_peer_node_ids(&this_arg_conv);
ptrArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native ptrArray Bytes");
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPublicKey their_node_id_ref;
CHECK(*((uint32_t*)their_node_id) == 33);
memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* descriptor_ptr = (void*)(((uint64_t)descriptor) & ~1);
CHECK_ACCESS(descriptor_ptr);
LDKSocketDescriptor descriptor_conv = *(LDKSocketDescriptor*)(descriptor_ptr);
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* descriptor_ptr = (void*)(((uint64_t)descriptor) & ~1);
if (!(descriptor & 1)) { CHECK_ACCESS(descriptor_ptr); }
LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)descriptor_ptr;
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* peer_descriptor_ptr = (void*)(((uint64_t)peer_descriptor) & ~1);
if (!(peer_descriptor & 1)) { CHECK_ACCESS(peer_descriptor_ptr); }
LDKSocketDescriptor* peer_descriptor_conv = (LDKSocketDescriptor*)peer_descriptor_ptr;
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
PeerManager_process_events(&this_arg_conv);
}
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* descriptor_ptr = (void*)(((uint64_t)descriptor) & ~1);
if (!(descriptor & 1)) { CHECK_ACCESS(descriptor_ptr); }
LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)descriptor_ptr;
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPublicKey node_id_ref;
CHECK(*((uint32_t*)node_id) == 33);
memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33);
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
PeerManager_disconnect_all_peers(&this_arg_conv);
}
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
PeerManager_timer_tick_occurred(&this_arg_conv);
}
LDKOutPoint funding_outpoint_conv;
funding_outpoint_conv.inner = (void*)(funding_outpoint & (~1));
funding_outpoint_conv.is_owned = (funding_outpoint & 1) || (funding_outpoint == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
LDKTransaction ret_var = build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script_ref, to_counterparty_script_ref, funding_outpoint_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
LDKTxCreationKeys this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
TxCreationKeys_free(this_obj_conv);
}
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), TxCreationKeys_get_per_commitment_point(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), TxCreationKeys_get_revocation_key(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), TxCreationKeys_get_broadcaster_htlc_key(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), TxCreationKeys_get_countersignatory_htlc_key(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), TxCreationKeys_get_broadcaster_delayed_payment_key(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg) {
+ LDKTxCreationKeys ret_var = TxCreationKeys_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_TxCreationKeys_clone_ptr(uint32_t arg) {
+ LDKTxCreationKeys arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = TxCreationKeys_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_TxCreationKeys_clone(uint32_t orig) {
LDKTxCreationKeys orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKTxCreationKeys ret_var = TxCreationKeys_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKTxCreationKeys obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = TxCreationKeys_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKChannelPublicKeys this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelPublicKeys_free(this_obj_conv);
}
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelPublicKeys_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelPublicKeys_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelPublicKeys_get_payment_point(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelPublicKeys_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelPublicKeys_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg) {
+ LDKChannelPublicKeys ret_var = ChannelPublicKeys_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelPublicKeys_clone_ptr(uint32_t arg) {
+ LDKChannelPublicKeys arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelPublicKeys_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelPublicKeys_clone(uint32_t orig) {
LDKChannelPublicKeys orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelPublicKeys ret_var = ChannelPublicKeys_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelPublicKeys obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelPublicKeys_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKChannelPublicKeys broadcaster_keys_conv;
broadcaster_keys_conv.inner = (void*)(broadcaster_keys & (~1));
broadcaster_keys_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(broadcaster_keys_conv);
LDKChannelPublicKeys countersignatory_keys_conv;
countersignatory_keys_conv.inner = (void*)(countersignatory_keys & (~1));
countersignatory_keys_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(countersignatory_keys_conv);
LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
*ret_conv = TxCreationKeys_from_channel_static_keys(per_commitment_point_ref, &broadcaster_keys_conv, &countersignatory_keys_conv);
return (uint64_t)ret_conv;
LDKHTLCOutputInCommitment this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
HTLCOutputInCommitment_free(this_obj_conv);
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = HTLCOutputInCommitment_get_offered(&this_ptr_conv);
return ret_val;
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
HTLCOutputInCommitment_set_offered(&this_ptr_conv, val);
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = HTLCOutputInCommitment_get_amount_msat(&this_ptr_conv);
return ret_val;
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
HTLCOutputInCommitment_set_amount_msat(&this_ptr_conv, val);
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = HTLCOutputInCommitment_get_cltv_expiry(&this_ptr_conv);
return ret_val;
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
HTLCOutputInCommitment_set_cltv_expiry(&this_ptr_conv, val);
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *HTLCOutputInCommitment_get_payment_hash(&this_ptr_conv), 32);
return ret_arr;
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
*ret_copy = HTLCOutputInCommitment_get_transaction_output_index(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg) {
+ LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_HTLCOutputInCommitment_clone_ptr(uint32_t arg) {
+ LDKHTLCOutputInCommitment arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = HTLCOutputInCommitment_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_HTLCOutputInCommitment_clone(uint32_t orig) {
LDKHTLCOutputInCommitment orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKHTLCOutputInCommitment obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = HTLCOutputInCommitment_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKHTLCOutputInCommitment htlc_conv;
htlc_conv.inner = (void*)(htlc & (~1));
htlc_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
LDKTxCreationKeys keys_conv;
keys_conv.inner = (void*)(keys & (~1));
keys_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(keys_conv);
LDKCVec_u8Z ret_var = get_htlc_redeemscript(&htlc_conv, &keys_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKHTLCOutputInCommitment htlc_conv;
htlc_conv.inner = (void*)(htlc & (~1));
htlc_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
LDKPublicKey broadcaster_delayed_payment_key_ref;
CHECK(*((uint32_t*)broadcaster_delayed_payment_key) == 33);
memcpy(broadcaster_delayed_payment_key_ref.compressed_form, (uint8_t*)(broadcaster_delayed_payment_key + 4), 33);
LDKChannelTransactionParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelTransactionParameters_free(this_obj_conv);
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelPublicKeys ret_var = ChannelTransactionParameters_get_holder_pubkeys(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelPublicKeys val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelPublicKeys_clone(&val_conv);
ChannelTransactionParameters_set_holder_pubkeys(&this_ptr_conv, val_conv);
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = ChannelTransactionParameters_get_holder_selected_contest_delay(&this_ptr_conv);
return ret_val;
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelTransactionParameters_set_holder_selected_contest_delay(&this_ptr_conv, val);
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelTransactionParameters_get_is_outbound_from_holder(&this_ptr_conv);
return ret_val;
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelTransactionParameters_set_is_outbound_from_holder(&this_ptr_conv, val);
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCounterpartyChannelTransactionParameters ret_var = ChannelTransactionParameters_get_counterparty_parameters(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCounterpartyChannelTransactionParameters val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = CounterpartyChannelTransactionParameters_clone(&val_conv);
ChannelTransactionParameters_set_counterparty_parameters(&this_ptr_conv, val_conv);
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint ret_var = ChannelTransactionParameters_get_funding_outpoint(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = OutPoint_clone(&val_conv);
ChannelTransactionParameters_set_funding_outpoint(&this_ptr_conv, val_conv);
}
LDKChannelPublicKeys holder_pubkeys_arg_conv;
holder_pubkeys_arg_conv.inner = (void*)(holder_pubkeys_arg & (~1));
holder_pubkeys_arg_conv.is_owned = (holder_pubkeys_arg & 1) || (holder_pubkeys_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_pubkeys_arg_conv);
holder_pubkeys_arg_conv = ChannelPublicKeys_clone(&holder_pubkeys_arg_conv);
LDKCounterpartyChannelTransactionParameters counterparty_parameters_arg_conv;
counterparty_parameters_arg_conv.inner = (void*)(counterparty_parameters_arg & (~1));
counterparty_parameters_arg_conv.is_owned = (counterparty_parameters_arg & 1) || (counterparty_parameters_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(counterparty_parameters_arg_conv);
counterparty_parameters_arg_conv = CounterpartyChannelTransactionParameters_clone(&counterparty_parameters_arg_conv);
LDKOutPoint funding_outpoint_arg_conv;
funding_outpoint_arg_conv.inner = (void*)(funding_outpoint_arg & (~1));
funding_outpoint_arg_conv.is_owned = (funding_outpoint_arg & 1) || (funding_outpoint_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_arg_conv);
funding_outpoint_arg_conv = OutPoint_clone(&funding_outpoint_arg_conv);
LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_new(holder_pubkeys_arg_conv, holder_selected_contest_delay_arg, is_outbound_from_holder_arg, counterparty_parameters_arg_conv, funding_outpoint_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg) {
+ LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelTransactionParameters_clone_ptr(uint32_t arg) {
+ LDKChannelTransactionParameters arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelTransactionParameters_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelTransactionParameters_clone(uint32_t orig) {
LDKChannelTransactionParameters orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCounterpartyChannelTransactionParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
CounterpartyChannelTransactionParameters_free(this_obj_conv);
}
LDKCounterpartyChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelPublicKeys ret_var = CounterpartyChannelTransactionParameters_get_pubkeys(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCounterpartyChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelPublicKeys val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelPublicKeys_clone(&val_conv);
CounterpartyChannelTransactionParameters_set_pubkeys(&this_ptr_conv, val_conv);
}
LDKCounterpartyChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = CounterpartyChannelTransactionParameters_get_selected_contest_delay(&this_ptr_conv);
return ret_val;
}
LDKCounterpartyChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
CounterpartyChannelTransactionParameters_set_selected_contest_delay(&this_ptr_conv, val);
}
LDKChannelPublicKeys pubkeys_arg_conv;
pubkeys_arg_conv.inner = (void*)(pubkeys_arg & (~1));
pubkeys_arg_conv.is_owned = (pubkeys_arg & 1) || (pubkeys_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_arg_conv);
pubkeys_arg_conv = ChannelPublicKeys_clone(&pubkeys_arg_conv);
LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_new(pubkeys_arg_conv, selected_contest_delay_arg);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg) {
+ LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_CounterpartyChannelTransactionParameters_clone_ptr(uint32_t arg) {
+ LDKCounterpartyChannelTransactionParameters arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = CounterpartyChannelTransactionParameters_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CounterpartyChannelTransactionParameters_clone(uint32_t orig) {
LDKCounterpartyChannelTransactionParameters orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = ChannelTransactionParameters_is_populated(&this_arg_conv);
return ret_val;
}
LDKChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_holder_broadcastable(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_counterparty_broadcastable(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCounterpartyChannelTransactionParameters obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = CounterpartyChannelTransactionParameters_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKChannelTransactionParameters obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelTransactionParameters_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKDirectedChannelTransactionParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DirectedChannelTransactionParameters_free(this_obj_conv);
}
LDKDirectedChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_broadcaster_pubkeys(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDirectedChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_countersignatory_pubkeys(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDirectedChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int16_t ret_val = DirectedChannelTransactionParameters_contest_delay(&this_arg_conv);
return ret_val;
}
LDKDirectedChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = DirectedChannelTransactionParameters_is_outbound(&this_arg_conv);
return ret_val;
}
LDKDirectedChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKOutPoint ret_var = DirectedChannelTransactionParameters_funding_outpoint(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKHolderCommitmentTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
HolderCommitmentTransaction_free(this_obj_conv);
}
LDKHolderCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), HolderCommitmentTransaction_get_counterparty_sig(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKHolderCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
LDKHolderCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_SignatureZ val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
HolderCommitmentTransaction_set_counterparty_htlc_sigs(&this_ptr_conv, val_constr);
}
+static inline uint64_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg) {
+ LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_HolderCommitmentTransaction_clone_ptr(uint32_t arg) {
+ LDKHolderCommitmentTransaction arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = HolderCommitmentTransaction_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_HolderCommitmentTransaction_clone(uint32_t orig) {
LDKHolderCommitmentTransaction orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKHolderCommitmentTransaction obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = HolderCommitmentTransaction_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKCommitmentTransaction commitment_tx_conv;
commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
commitment_tx_conv.is_owned = (commitment_tx & 1) || (commitment_tx == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
commitment_tx_conv = CommitmentTransaction_clone(&commitment_tx_conv);
LDKSignature counterparty_sig_ref;
CHECK(*((uint32_t*)counterparty_sig) == 64);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKBuiltCommitmentTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
BuiltCommitmentTransaction_free(this_obj_conv);
}
LDKBuiltCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKTransaction ret_var = BuiltCommitmentTransaction_get_transaction(&this_ptr_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKBuiltCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKTransaction val_ref;
val_ref.datalen = *((uint32_t*)val);
val_ref.data = MALLOC(val_ref.datalen, "LDKTransaction Bytes");
LDKBuiltCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *BuiltCommitmentTransaction_get_txid(&this_ptr_conv), 32);
return ret_arr;
LDKBuiltCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg) {
+ LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_BuiltCommitmentTransaction_clone_ptr(uint32_t arg) {
+ LDKBuiltCommitmentTransaction arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = BuiltCommitmentTransaction_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_BuiltCommitmentTransaction_clone(uint32_t orig) {
LDKBuiltCommitmentTransaction orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKBuiltCommitmentTransaction obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = BuiltCommitmentTransaction_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKBuiltCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKu8slice funding_redeemscript_ref;
funding_redeemscript_ref.datalen = *((uint32_t*)funding_redeemscript);
funding_redeemscript_ref.data = (int8_t*)(funding_redeemscript + 4);
LDKBuiltCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char funding_key_arr[32];
CHECK(*((uint32_t*)funding_key) == 32);
memcpy(funding_key_arr, (uint8_t*)(funding_key + 4), 32);
LDKClosingTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ClosingTransaction_free(this_obj_conv);
}
+static inline uint64_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg) {
+ LDKClosingTransaction ret_var = ClosingTransaction_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ClosingTransaction_clone_ptr(uint32_t arg) {
+ LDKClosingTransaction arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ClosingTransaction_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ClosingTransaction_clone(uint32_t orig) {
LDKClosingTransaction orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKClosingTransaction ret_var = ClosingTransaction_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = ClosingTransaction_hash(&o_conv);
return ret_val;
}
LDKOutPoint funding_outpoint_conv;
funding_outpoint_conv.inner = (void*)(funding_outpoint & (~1));
funding_outpoint_conv.is_owned = (funding_outpoint & 1) || (funding_outpoint == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
LDKClosingTransaction ret_var = ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script_ref, to_counterparty_script_ref, funding_outpoint_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTrustedClosingTransaction ret_var = ClosingTransaction_trust(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKOutPoint funding_outpoint_conv;
funding_outpoint_conv.inner = (void*)(funding_outpoint & (~1));
funding_outpoint_conv.is_owned = (funding_outpoint & 1) || (funding_outpoint == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
*ret_conv = ClosingTransaction_verify(&this_arg_conv, funding_outpoint_conv);
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = ClosingTransaction_to_holder_value_sat(&this_arg_conv);
return ret_val;
}
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = ClosingTransaction_to_counterparty_value_sat(&this_arg_conv);
return ret_val;
}
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKu8slice ret_var = ClosingTransaction_to_holder_script(&this_arg_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKu8slice ret_var = ClosingTransaction_to_counterparty_script(&this_arg_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKTrustedClosingTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
TrustedClosingTransaction_free(this_obj_conv);
}
LDKTrustedClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTransaction ret_var = TrustedClosingTransaction_built_transaction(&this_arg_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKTrustedClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKu8slice funding_redeemscript_ref;
funding_redeemscript_ref.datalen = *((uint32_t*)funding_redeemscript);
funding_redeemscript_ref.data = (int8_t*)(funding_redeemscript + 4);
LDKTrustedClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char funding_key_arr[32];
CHECK(*((uint32_t*)funding_key) == 32);
memcpy(funding_key_arr, (uint8_t*)(funding_key + 4), 32);
LDKCommitmentTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
CommitmentTransaction_free(this_obj_conv);
}
+static inline uint64_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg) {
+ LDKCommitmentTransaction ret_var = CommitmentTransaction_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_CommitmentTransaction_clone_ptr(uint32_t arg) {
+ LDKCommitmentTransaction arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = CommitmentTransaction_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CommitmentTransaction_clone(uint32_t orig) {
LDKCommitmentTransaction orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKCommitmentTransaction ret_var = CommitmentTransaction_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentTransaction obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = CommitmentTransaction_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = CommitmentTransaction_commitment_number(&this_arg_conv);
return ret_val;
}
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = CommitmentTransaction_to_broadcaster_value_sat(&this_arg_conv);
return ret_val;
}
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = CommitmentTransaction_to_countersignatory_value_sat(&this_arg_conv);
return ret_val;
}
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int32_t ret_val = CommitmentTransaction_feerate_per_kw(&this_arg_conv);
return ret_val;
}
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTrustedCommitmentTransaction ret_var = CommitmentTransaction_trust(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKDirectedChannelTransactionParameters channel_parameters_conv;
channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
channel_parameters_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
LDKChannelPublicKeys broadcaster_keys_conv;
broadcaster_keys_conv.inner = (void*)(broadcaster_keys & (~1));
broadcaster_keys_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(broadcaster_keys_conv);
LDKChannelPublicKeys countersignatory_keys_conv;
countersignatory_keys_conv.inner = (void*)(countersignatory_keys & (~1));
countersignatory_keys_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(countersignatory_keys_conv);
LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
*ret_conv = CommitmentTransaction_verify(&this_arg_conv, &channel_parameters_conv, &broadcaster_keys_conv, &countersignatory_keys_conv);
return (uint64_t)ret_conv;
LDKTrustedCommitmentTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
TrustedCommitmentTransaction_free(this_obj_conv);
}
LDKTrustedCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), TrustedCommitmentTransaction_txid(&this_arg_conv).data, 32);
return ret_arr;
LDKTrustedCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKBuiltCommitmentTransaction ret_var = TrustedCommitmentTransaction_built_transaction(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKTrustedCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTxCreationKeys ret_var = TrustedCommitmentTransaction_keys(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKTrustedCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char htlc_base_key_arr[32];
CHECK(*((uint32_t*)htlc_base_key) == 32);
memcpy(htlc_base_key_arr, (uint8_t*)(htlc_base_key + 4), 32);
LDKDirectedChannelTransactionParameters channel_parameters_conv;
channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
channel_parameters_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
*ret_conv = TrustedCommitmentTransaction_get_htlc_sigs(&this_arg_conv, htlc_base_key_ref, &channel_parameters_conv);
return (uint64_t)ret_conv;
LDKInitFeatures a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKInitFeatures b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = InitFeatures_eq(&a_conv, &b_conv);
return ret_val;
}
LDKNodeFeatures a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKNodeFeatures b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = NodeFeatures_eq(&a_conv, &b_conv);
return ret_val;
}
LDKChannelFeatures a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKChannelFeatures b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = ChannelFeatures_eq(&a_conv, &b_conv);
return ret_val;
}
LDKInvoiceFeatures a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKInvoiceFeatures b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = InvoiceFeatures_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg) {
+ LDKInitFeatures ret_var = InitFeatures_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_InitFeatures_clone_ptr(uint32_t arg) {
+ LDKInitFeatures arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = InitFeatures_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_InitFeatures_clone(uint32_t orig) {
LDKInitFeatures orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInitFeatures ret_var = InitFeatures_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg) {
+ LDKNodeFeatures ret_var = NodeFeatures_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_NodeFeatures_clone_ptr(uint32_t arg) {
+ LDKNodeFeatures arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NodeFeatures_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_NodeFeatures_clone(uint32_t orig) {
LDKNodeFeatures orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNodeFeatures ret_var = NodeFeatures_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg) {
+ LDKChannelFeatures ret_var = ChannelFeatures_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelFeatures_clone_ptr(uint32_t arg) {
+ LDKChannelFeatures arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelFeatures_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelFeatures_clone(uint32_t orig) {
LDKChannelFeatures orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelFeatures ret_var = ChannelFeatures_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg) {
+ LDKInvoiceFeatures ret_var = InvoiceFeatures_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_InvoiceFeatures_clone_ptr(uint32_t arg) {
+ LDKInvoiceFeatures arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = InvoiceFeatures_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_InvoiceFeatures_clone(uint32_t orig) {
LDKInvoiceFeatures orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInvoiceFeatures ret_var = InvoiceFeatures_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInitFeatures this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InitFeatures_free(this_obj_conv);
}
LDKNodeFeatures this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NodeFeatures_free(this_obj_conv);
}
LDKChannelFeatures this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelFeatures_free(this_obj_conv);
}
LDKInvoiceFeatures this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InvoiceFeatures_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInitFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = InitFeatures_requires_unknown_bits(&this_arg_conv);
return ret_val;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = NodeFeatures_requires_unknown_bits(&this_arg_conv);
return ret_val;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = ChannelFeatures_requires_unknown_bits(&this_arg_conv);
return ret_val;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvoiceFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = InvoiceFeatures_requires_unknown_bits(&this_arg_conv);
return ret_val;
}
LDKInitFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = InitFeatures_supports_payment_secret(&this_arg_conv);
return ret_val;
}
LDKNodeFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = NodeFeatures_supports_payment_secret(&this_arg_conv);
return ret_val;
}
LDKInvoiceFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = InvoiceFeatures_supports_payment_secret(&this_arg_conv);
return ret_val;
}
LDKInitFeatures obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = InitFeatures_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKNodeFeatures obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NodeFeatures_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKChannelFeatures obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelFeatures_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKInvoiceFeatures obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = InvoiceFeatures_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKShutdownScript this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ShutdownScript_free(this_obj_conv);
}
+static inline uint64_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg) {
+ LDKShutdownScript ret_var = ShutdownScript_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ShutdownScript_clone_ptr(uint32_t arg) {
+ LDKShutdownScript arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ShutdownScript_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ShutdownScript_clone(uint32_t orig) {
LDKShutdownScript orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKShutdownScript ret_var = ShutdownScript_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvalidShutdownScript this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InvalidShutdownScript_free(this_obj_conv);
}
LDKInvalidShutdownScript this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKu8slice ret_var = InvalidShutdownScript_get_script(&this_ptr_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKInvalidShutdownScript this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u8Z val_ref;
val_ref.datalen = *((uint32_t*)val);
val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg) {
+ LDKInvalidShutdownScript ret_var = InvalidShutdownScript_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_InvalidShutdownScript_clone_ptr(uint32_t arg) {
+ LDKInvalidShutdownScript arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = InvalidShutdownScript_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_InvalidShutdownScript_clone(uint32_t orig) {
LDKInvalidShutdownScript orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInvalidShutdownScript ret_var = InvalidShutdownScript_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKShutdownScript obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ShutdownScript_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKShutdownScript this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
this_arg_conv = ShutdownScript_clone(&this_arg_conv);
LDKCVec_u8Z ret_var = ShutdownScript_into_inner(this_arg_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
LDKShutdownScript this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ShutdownScript_as_legacy_pubkey(&this_arg_conv).compressed_form, 33);
return ret_arr;
LDKShutdownScript this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInitFeatures features_conv;
features_conv.inner = (void*)(features & (~1));
features_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_conv);
jboolean ret_val = ShutdownScript_is_compatible(&this_arg_conv, &features_conv);
return ret_val;
}
CustomMessageReader_free(this_ptr_conv);
}
+static inline uint64_t Type_clone_ptr(LDKType *NONNULL_PTR arg) {
+ LDKType* ret_ret = MALLOC(sizeof(LDKType), "LDKType");
+ *ret_ret = Type_clone(arg);
+ return (uint64_t)ret_ret;
+}
+int64_t __attribute__((visibility("default"))) TS_Type_clone_ptr(uint32_t arg) {
+ void* arg_ptr = (void*)(((uint64_t)arg) & ~1);
+ if (!(arg & 1)) { CHECK_ACCESS(arg_ptr); }
+ LDKType* arg_conv = (LDKType*)arg_ptr;
+ int64_t ret_val = Type_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Type_clone(uint32_t orig) {
void* orig_ptr = (void*)(((uint64_t)orig) & ~1);
if (!(orig & 1)) { CHECK_ACCESS(orig_ptr); }
LDKLockableScore this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
LockableScore_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKLockableScore obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = LockableScore_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKNodeId this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NodeId_free(this_obj_conv);
}
+static inline uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg) {
+ LDKNodeId ret_var = NodeId_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_NodeId_clone_ptr(uint32_t arg) {
+ LDKNodeId arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NodeId_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_NodeId_clone(uint32_t orig) {
LDKNodeId orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNodeId ret_var = NodeId_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeId this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKu8slice ret_var = NodeId_as_slice(&this_arg_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKNodeId o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = NodeId_hash(&o_conv);
return ret_val;
}
LDKNodeId obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NodeId_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKNetworkGraph this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NetworkGraph_free(this_obj_conv);
}
+static inline uint64_t NetworkGraph_clone_ptr(LDKNetworkGraph *NONNULL_PTR arg) {
+ LDKNetworkGraph ret_var = NetworkGraph_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_NetworkGraph_clone_ptr(uint32_t arg) {
+ LDKNetworkGraph arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NetworkGraph_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_clone(uint32_t orig) {
LDKNetworkGraph orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNetworkGraph ret_var = NetworkGraph_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKReadOnlyNetworkGraph this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ReadOnlyNetworkGraph_free(this_obj_conv);
}
NetworkUpdate_free(this_ptr_conv);
}
+static inline uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg) {
+ LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
+ *ret_copy = NetworkUpdate_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_NetworkUpdate_clone_ptr(uint32_t arg) {
+ LDKNetworkUpdate* arg_conv = (LDKNetworkUpdate*)arg;
+ int64_t ret_val = NetworkUpdate_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_NetworkUpdate_clone(uint32_t orig) {
LDKNetworkUpdate* orig_conv = (LDKNetworkUpdate*)orig;
LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ChannelUpdate_clone(&msg_conv);
LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
*ret_copy = NetworkUpdate_channel_update_message(msg_conv);
return ret_arr;
}
+uint32_t __attribute__((visibility("default"))) TS_NetworkUpdate_read(int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = *((uint32_t*)ser);
+ ser_ref.data = (int8_t*)(ser + 4);
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = NetworkUpdate_read(ser_ref);
+ return (uint64_t)ret_conv;
+}
+
uint32_t __attribute__((visibility("default"))) TS_NetGraphMsgHandler_as_EventHandler(uint32_t this_arg) {
LDKNetGraphMsgHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKEventHandler* ret_ret = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
*ret_ret = NetGraphMsgHandler_as_EventHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKNetGraphMsgHandler this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NetGraphMsgHandler_free(this_obj_conv);
}
LDKNetworkGraph network_graph_conv;
network_graph_conv.inner = (void*)(network_graph & (~1));
network_graph_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
void* chain_access_ptr = (void*)(((uint64_t)chain_access) & ~1);
CHECK_ACCESS(chain_access_ptr);
LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNetGraphMsgHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* chain_access_ptr = (void*)(((uint64_t)chain_access) & ~1);
CHECK_ACCESS(chain_access_ptr);
LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
LDKNetGraphMsgHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRoutingMessageHandler* ret_ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
*ret_ret = NetGraphMsgHandler_as_RoutingMessageHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKNetGraphMsgHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
*ret_ret = NetGraphMsgHandler_as_MessageSendEventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKDirectionalChannelInfo this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DirectionalChannelInfo_free(this_obj_conv);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = DirectionalChannelInfo_get_last_update(&this_ptr_conv);
return ret_val;
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DirectionalChannelInfo_set_last_update(&this_ptr_conv, val);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = DirectionalChannelInfo_get_enabled(&this_ptr_conv);
return ret_val;
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DirectionalChannelInfo_set_enabled(&this_ptr_conv, val);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = DirectionalChannelInfo_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DirectionalChannelInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = DirectionalChannelInfo_get_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DirectionalChannelInfo_set_htlc_minimum_msat(&this_ptr_conv, val);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = DirectionalChannelInfo_get_htlc_maximum_msat(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees ret_var = DirectionalChannelInfo_get_fees(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = RoutingFees_clone(&val_conv);
DirectionalChannelInfo_set_fees(&this_ptr_conv, val_conv);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelUpdate ret_var = DirectionalChannelInfo_get_last_update_message(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelUpdate val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelUpdate_clone(&val_conv);
DirectionalChannelInfo_set_last_update_message(&this_ptr_conv, val_conv);
}
LDKRoutingFees fees_arg_conv;
fees_arg_conv.inner = (void*)(fees_arg & (~1));
fees_arg_conv.is_owned = (fees_arg & 1) || (fees_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(fees_arg_conv);
fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
LDKChannelUpdate last_update_message_arg_conv;
last_update_message_arg_conv.inner = (void*)(last_update_message_arg & (~1));
last_update_message_arg_conv.is_owned = (last_update_message_arg & 1) || (last_update_message_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(last_update_message_arg_conv);
last_update_message_arg_conv = ChannelUpdate_clone(&last_update_message_arg_conv);
LDKDirectionalChannelInfo ret_var = DirectionalChannelInfo_new(last_update_arg, enabled_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg_conv, fees_arg_conv, last_update_message_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t DirectionalChannelInfo_clone_ptr(LDKDirectionalChannelInfo *NONNULL_PTR arg) {
+ LDKDirectionalChannelInfo ret_var = DirectionalChannelInfo_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_clone_ptr(uint32_t arg) {
+ LDKDirectionalChannelInfo arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = DirectionalChannelInfo_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_clone(uint32_t orig) {
LDKDirectionalChannelInfo orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKDirectionalChannelInfo ret_var = DirectionalChannelInfo_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDirectionalChannelInfo obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = DirectionalChannelInfo_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKChannelInfo this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelInfo_free(this_obj_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures ret_var = ChannelInfo_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelFeatures_clone(&val_conv);
ChannelInfo_set_features(&this_ptr_conv, val_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeId ret_var = ChannelInfo_get_node_one(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeId val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeId_clone(&val_conv);
ChannelInfo_set_node_one(&this_ptr_conv, val_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKDirectionalChannelInfo ret_var = ChannelInfo_get_one_to_two(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKDirectionalChannelInfo val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = DirectionalChannelInfo_clone(&val_conv);
ChannelInfo_set_one_to_two(&this_ptr_conv, val_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeId ret_var = ChannelInfo_get_node_two(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeId val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeId_clone(&val_conv);
ChannelInfo_set_node_two(&this_ptr_conv, val_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKDirectionalChannelInfo ret_var = ChannelInfo_get_two_to_one(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKDirectionalChannelInfo val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = DirectionalChannelInfo_clone(&val_conv);
ChannelInfo_set_two_to_one(&this_ptr_conv, val_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = ChannelInfo_get_capacity_sats(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelAnnouncement ret_var = ChannelInfo_get_announcement_message(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelAnnouncement val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelAnnouncement_clone(&val_conv);
ChannelInfo_set_announcement_message(&this_ptr_conv, val_conv);
}
LDKChannelFeatures features_arg_conv;
features_arg_conv.inner = (void*)(features_arg & (~1));
features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
features_arg_conv = ChannelFeatures_clone(&features_arg_conv);
LDKNodeId node_one_arg_conv;
node_one_arg_conv.inner = (void*)(node_one_arg & (~1));
node_one_arg_conv.is_owned = (node_one_arg & 1) || (node_one_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(node_one_arg_conv);
node_one_arg_conv = NodeId_clone(&node_one_arg_conv);
LDKDirectionalChannelInfo one_to_two_arg_conv;
one_to_two_arg_conv.inner = (void*)(one_to_two_arg & (~1));
one_to_two_arg_conv.is_owned = (one_to_two_arg & 1) || (one_to_two_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(one_to_two_arg_conv);
one_to_two_arg_conv = DirectionalChannelInfo_clone(&one_to_two_arg_conv);
LDKNodeId node_two_arg_conv;
node_two_arg_conv.inner = (void*)(node_two_arg & (~1));
node_two_arg_conv.is_owned = (node_two_arg & 1) || (node_two_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(node_two_arg_conv);
node_two_arg_conv = NodeId_clone(&node_two_arg_conv);
LDKDirectionalChannelInfo two_to_one_arg_conv;
two_to_one_arg_conv.inner = (void*)(two_to_one_arg & (~1));
two_to_one_arg_conv.is_owned = (two_to_one_arg & 1) || (two_to_one_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(two_to_one_arg_conv);
two_to_one_arg_conv = DirectionalChannelInfo_clone(&two_to_one_arg_conv);
void* capacity_sats_arg_ptr = (void*)(((uint64_t)capacity_sats_arg) & ~1);
CHECK_ACCESS(capacity_sats_arg_ptr);
LDKChannelAnnouncement announcement_message_arg_conv;
announcement_message_arg_conv.inner = (void*)(announcement_message_arg & (~1));
announcement_message_arg_conv.is_owned = (announcement_message_arg & 1) || (announcement_message_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(announcement_message_arg_conv);
announcement_message_arg_conv = ChannelAnnouncement_clone(&announcement_message_arg_conv);
LDKChannelInfo ret_var = ChannelInfo_new(features_arg_conv, node_one_arg_conv, one_to_two_arg_conv, node_two_arg_conv, two_to_one_arg_conv, capacity_sats_arg_conv, announcement_message_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg) {
+ LDKChannelInfo ret_var = ChannelInfo_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelInfo_clone_ptr(uint32_t arg) {
+ LDKChannelInfo arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelInfo_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_clone(uint32_t orig) {
LDKChannelInfo orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelInfo ret_var = ChannelInfo_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelInfo_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKRoutingFees this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RoutingFees_free(this_obj_conv);
}
LDKRoutingFees this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = RoutingFees_get_base_msat(&this_ptr_conv);
return ret_val;
}
LDKRoutingFees this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RoutingFees_set_base_msat(&this_ptr_conv, val);
}
LDKRoutingFees this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = RoutingFees_get_proportional_millionths(&this_ptr_conv);
return ret_val;
}
LDKRoutingFees this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RoutingFees_set_proportional_millionths(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRoutingFees a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRoutingFees b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RoutingFees_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg) {
+ LDKRoutingFees ret_var = RoutingFees_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_RoutingFees_clone_ptr(uint32_t arg) {
+ LDKRoutingFees arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RoutingFees_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_RoutingFees_clone(uint32_t orig) {
LDKRoutingFees orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRoutingFees ret_var = RoutingFees_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRoutingFees o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = RoutingFees_hash(&o_conv);
return ret_val;
}
LDKRoutingFees obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RoutingFees_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKNodeAnnouncementInfo this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NodeAnnouncementInfo_free(this_obj_conv);
}
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures ret_var = NodeAnnouncementInfo_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeFeatures_clone(&val_conv);
NodeAnnouncementInfo_set_features(&this_ptr_conv, val_conv);
}
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = NodeAnnouncementInfo_get_last_update(&this_ptr_conv);
return ret_val;
}
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
NodeAnnouncementInfo_set_last_update(&this_ptr_conv, val);
}
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(3, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *NodeAnnouncementInfo_get_rgb(&this_ptr_conv), 3);
return ret_arr;
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThreeBytes val_ref;
CHECK(*((uint32_t*)val) == 3);
memcpy(val_ref.data, (uint8_t*)(val + 4), 3);
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *NodeAnnouncementInfo_get_alias(&this_ptr_conv), 32);
return ret_arr;
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_NetAddressZ val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeAnnouncement ret_var = NodeAnnouncementInfo_get_announcement_message(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeAnnouncement val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeAnnouncement_clone(&val_conv);
NodeAnnouncementInfo_set_announcement_message(&this_ptr_conv, val_conv);
}
LDKNodeFeatures features_arg_conv;
features_arg_conv.inner = (void*)(features_arg & (~1));
features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
features_arg_conv = NodeFeatures_clone(&features_arg_conv);
LDKThreeBytes rgb_arg_ref;
CHECK(*((uint32_t*)rgb_arg) == 3);
LDKNodeAnnouncement announcement_message_arg_conv;
announcement_message_arg_conv.inner = (void*)(announcement_message_arg & (~1));
announcement_message_arg_conv.is_owned = (announcement_message_arg & 1) || (announcement_message_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(announcement_message_arg_conv);
announcement_message_arg_conv = NodeAnnouncement_clone(&announcement_message_arg_conv);
LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_new(features_arg_conv, last_update_arg, rgb_arg_ref, alias_arg_ref, addresses_arg_constr, announcement_message_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg) {
+ LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_clone_ptr(uint32_t arg) {
+ LDKNodeAnnouncementInfo arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NodeAnnouncementInfo_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_clone(uint32_t orig) {
LDKNodeAnnouncementInfo orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeAnnouncementInfo obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NodeAnnouncementInfo_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKNodeInfo this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NodeInfo_free(this_obj_conv);
}
LDKNodeInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u64Z val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
LDKNodeInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees ret_var = NodeInfo_get_lowest_inbound_channel_fees(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = RoutingFees_clone(&val_conv);
NodeInfo_set_lowest_inbound_channel_fees(&this_ptr_conv, val_conv);
}
LDKNodeInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeAnnouncementInfo ret_var = NodeInfo_get_announcement_info(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeAnnouncementInfo val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeAnnouncementInfo_clone(&val_conv);
NodeInfo_set_announcement_info(&this_ptr_conv, val_conv);
}
LDKRoutingFees lowest_inbound_channel_fees_arg_conv;
lowest_inbound_channel_fees_arg_conv.inner = (void*)(lowest_inbound_channel_fees_arg & (~1));
lowest_inbound_channel_fees_arg_conv.is_owned = (lowest_inbound_channel_fees_arg & 1) || (lowest_inbound_channel_fees_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(lowest_inbound_channel_fees_arg_conv);
lowest_inbound_channel_fees_arg_conv = RoutingFees_clone(&lowest_inbound_channel_fees_arg_conv);
LDKNodeAnnouncementInfo announcement_info_arg_conv;
announcement_info_arg_conv.inner = (void*)(announcement_info_arg & (~1));
announcement_info_arg_conv.is_owned = (announcement_info_arg & 1) || (announcement_info_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(announcement_info_arg_conv);
announcement_info_arg_conv = NodeAnnouncementInfo_clone(&announcement_info_arg_conv);
LDKNodeInfo ret_var = NodeInfo_new(channels_arg_constr, lowest_inbound_channel_fees_arg_conv, announcement_info_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg) {
+ LDKNodeInfo ret_var = NodeInfo_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_NodeInfo_clone_ptr(uint32_t arg) {
+ LDKNodeInfo arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NodeInfo_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_NodeInfo_clone(uint32_t orig) {
LDKNodeInfo orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNodeInfo ret_var = NodeInfo_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeInfo obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NodeInfo_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKNetworkGraph obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NetworkGraph_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKReadOnlyNetworkGraph ret_var = NetworkGraph_read_only(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKNodeAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = NetworkGraph_update_node_from_announcement(&this_arg_conv, &msg_conv);
return (uint64_t)ret_conv;
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKUnsignedNodeAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = NetworkGraph_update_node_from_unsigned_announcement(&this_arg_conv, &msg_conv);
return (uint64_t)ret_conv;
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
void* chain_access_ptr = (void*)(((uint64_t)chain_access) & ~1);
CHECK_ACCESS(chain_access_ptr);
LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKUnsignedChannelAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
void* chain_access_ptr = (void*)(((uint64_t)chain_access) & ~1);
CHECK_ACCESS(chain_access_ptr);
LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
NetworkGraph_close_channel_from_update(&this_arg_conv, short_channel_id, is_permanent);
}
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPublicKey _node_id_ref;
CHECK(*((uint32_t*)_node_id) == 33);
memcpy(_node_id_ref.compressed_form, (uint8_t*)(_node_id + 4), 33);
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = NetworkGraph_update_channel(&this_arg_conv, &msg_conv);
return (uint64_t)ret_conv;
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKUnsignedChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = NetworkGraph_update_channel_unsigned(&this_arg_conv, &msg_conv);
return (uint64_t)ret_conv;
LDKReadOnlyNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPublicKey pubkey_ref;
CHECK(*((uint32_t*)pubkey) == 33);
memcpy(pubkey_ref.compressed_form, (uint8_t*)(pubkey + 4), 33);
LDKRouteHop this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RouteHop_free(this_obj_conv);
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), RouteHop_get_pubkey(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures ret_var = RouteHop_get_node_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeFeatures_clone(&val_conv);
RouteHop_set_node_features(&this_ptr_conv, val_conv);
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = RouteHop_get_short_channel_id(&this_ptr_conv);
return ret_val;
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteHop_set_short_channel_id(&this_ptr_conv, val);
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures ret_var = RouteHop_get_channel_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelFeatures_clone(&val_conv);
RouteHop_set_channel_features(&this_ptr_conv, val_conv);
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = RouteHop_get_fee_msat(&this_ptr_conv);
return ret_val;
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteHop_set_fee_msat(&this_ptr_conv, val);
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = RouteHop_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteHop_set_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKNodeFeatures node_features_arg_conv;
node_features_arg_conv.inner = (void*)(node_features_arg & (~1));
node_features_arg_conv.is_owned = (node_features_arg & 1) || (node_features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(node_features_arg_conv);
node_features_arg_conv = NodeFeatures_clone(&node_features_arg_conv);
LDKChannelFeatures channel_features_arg_conv;
channel_features_arg_conv.inner = (void*)(channel_features_arg & (~1));
channel_features_arg_conv.is_owned = (channel_features_arg & 1) || (channel_features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_features_arg_conv);
channel_features_arg_conv = ChannelFeatures_clone(&channel_features_arg_conv);
LDKRouteHop ret_var = RouteHop_new(pubkey_arg_ref, node_features_arg_conv, short_channel_id_arg, channel_features_arg_conv, fee_msat_arg, cltv_expiry_delta_arg);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg) {
+ LDKRouteHop ret_var = RouteHop_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_RouteHop_clone_ptr(uint32_t arg) {
+ LDKRouteHop arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RouteHop_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_RouteHop_clone(uint32_t orig) {
LDKRouteHop orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRouteHop ret_var = RouteHop_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHop o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = RouteHop_hash(&o_conv);
return ret_val;
}
LDKRouteHop a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRouteHop b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RouteHop_eq(&a_conv, &b_conv);
return ret_val;
}
LDKRouteHop obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RouteHop_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKRoute this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Route_free(this_obj_conv);
}
LDKRoute this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_CVec_RouteHopZZ ret_var = Route_get_paths(&this_ptr_conv);
ptrArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native ptrArray Bytes");
uint64_t ret_conv_12_conv_10_ref = 0;
CHECK((((uint64_t)ret_conv_12_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_12_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_12_conv_10_var);
ret_conv_12_conv_10_ref = (uint64_t)ret_conv_12_conv_10_var.inner;
if (ret_conv_12_conv_10_var.is_owned) {
ret_conv_12_conv_10_ref |= 1;
LDKRoute this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_CVec_RouteHopZZ val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
LDKRouteHop val_conv_12_conv_10_conv;
val_conv_12_conv_10_conv.inner = (void*)(val_conv_12_conv_10 & (~1));
val_conv_12_conv_10_conv.is_owned = (val_conv_12_conv_10 & 1) || (val_conv_12_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_12_conv_10_conv);
val_conv_12_conv_10_conv = RouteHop_clone(&val_conv_12_conv_10_conv);
val_conv_12_constr.data[k] = val_conv_12_conv_10_conv;
}
LDKRoute this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPayee ret_var = Route_get_payee(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRoute this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPayee val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = Payee_clone(&val_conv);
Route_set_payee(&this_ptr_conv, val_conv);
}
LDKRouteHop paths_arg_conv_12_conv_10_conv;
paths_arg_conv_12_conv_10_conv.inner = (void*)(paths_arg_conv_12_conv_10 & (~1));
paths_arg_conv_12_conv_10_conv.is_owned = (paths_arg_conv_12_conv_10 & 1) || (paths_arg_conv_12_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(paths_arg_conv_12_conv_10_conv);
paths_arg_conv_12_conv_10_conv = RouteHop_clone(&paths_arg_conv_12_conv_10_conv);
paths_arg_conv_12_constr.data[k] = paths_arg_conv_12_conv_10_conv;
}
LDKPayee payee_arg_conv;
payee_arg_conv.inner = (void*)(payee_arg & (~1));
payee_arg_conv.is_owned = (payee_arg & 1) || (payee_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(payee_arg_conv);
payee_arg_conv = Payee_clone(&payee_arg_conv);
LDKRoute ret_var = Route_new(paths_arg_constr, payee_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg) {
+ LDKRoute ret_var = Route_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Route_clone_ptr(uint32_t arg) {
+ LDKRoute arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Route_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Route_clone(uint32_t orig) {
LDKRoute orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRoute ret_var = Route_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRoute o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = Route_hash(&o_conv);
return ret_val;
}
LDKRoute a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRoute b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = Route_eq(&a_conv, &b_conv);
return ret_val;
}
LDKRoute this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = Route_get_total_fees(&this_arg_conv);
return ret_val;
}
LDKRoute this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = Route_get_total_amount(&this_arg_conv);
return ret_val;
}
LDKRoute obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Route_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKRouteParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RouteParameters_free(this_obj_conv);
}
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPayee ret_var = RouteParameters_get_payee(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPayee val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = Payee_clone(&val_conv);
RouteParameters_set_payee(&this_ptr_conv, val_conv);
}
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = RouteParameters_get_final_value_msat(&this_ptr_conv);
return ret_val;
}
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteParameters_set_final_value_msat(&this_ptr_conv, val);
}
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = RouteParameters_get_final_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteParameters_set_final_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKPayee payee_arg_conv;
payee_arg_conv.inner = (void*)(payee_arg & (~1));
payee_arg_conv.is_owned = (payee_arg & 1) || (payee_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(payee_arg_conv);
payee_arg_conv = Payee_clone(&payee_arg_conv);
LDKRouteParameters ret_var = RouteParameters_new(payee_arg_conv, final_value_msat_arg, final_cltv_expiry_delta_arg);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg) {
+ LDKRouteParameters ret_var = RouteParameters_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_RouteParameters_clone_ptr(uint32_t arg) {
+ LDKRouteParameters arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RouteParameters_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_RouteParameters_clone(uint32_t orig) {
LDKRouteParameters orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRouteParameters ret_var = RouteParameters_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteParameters obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RouteParameters_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKPayee this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Payee_free(this_obj_conv);
}
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), Payee_get_pubkey(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInvoiceFeatures ret_var = Payee_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInvoiceFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = InvoiceFeatures_clone(&val_conv);
Payee_set_features(&this_ptr_conv, val_conv);
}
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_RouteHintZ ret_var = Payee_get_route_hints(&this_ptr_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_11_ref = 0;
CHECK((((uint64_t)ret_conv_11_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_11_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_11_var);
ret_conv_11_ref = (uint64_t)ret_conv_11_var.inner;
if (ret_conv_11_var.is_owned) {
ret_conv_11_ref |= 1;
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_RouteHintZ val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
LDKRouteHint val_conv_11_conv;
val_conv_11_conv.inner = (void*)(val_conv_11 & (~1));
val_conv_11_conv.is_owned = (val_conv_11 & 1) || (val_conv_11 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_11_conv);
val_conv_11_conv = RouteHint_clone(&val_conv_11_conv);
val_constr.data[l] = val_conv_11_conv;
}
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = Payee_get_expiry_time(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKInvoiceFeatures features_arg_conv;
features_arg_conv.inner = (void*)(features_arg & (~1));
features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
features_arg_conv = InvoiceFeatures_clone(&features_arg_conv);
LDKCVec_RouteHintZ route_hints_arg_constr;
route_hints_arg_constr.datalen = *((uint32_t*)route_hints_arg);
LDKRouteHint route_hints_arg_conv_11_conv;
route_hints_arg_conv_11_conv.inner = (void*)(route_hints_arg_conv_11 & (~1));
route_hints_arg_conv_11_conv.is_owned = (route_hints_arg_conv_11 & 1) || (route_hints_arg_conv_11 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_hints_arg_conv_11_conv);
route_hints_arg_conv_11_conv = RouteHint_clone(&route_hints_arg_conv_11_conv);
route_hints_arg_constr.data[l] = route_hints_arg_conv_11_conv;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Payee_clone_ptr(LDKPayee *NONNULL_PTR arg) {
+ LDKPayee ret_var = Payee_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Payee_clone_ptr(uint32_t arg) {
+ LDKPayee arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Payee_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Payee_clone(uint32_t orig) {
LDKPayee orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPayee ret_var = Payee_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPayee o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = Payee_hash(&o_conv);
return ret_val;
}
LDKPayee a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKPayee b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = Payee_eq(&a_conv, &b_conv);
return ret_val;
}
LDKPayee obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Payee_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHint this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RouteHint_free(this_obj_conv);
}
LDKRouteHint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_RouteHintHopZ ret_var = RouteHint_get_a(&this_ptr_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_14_ref = 0;
CHECK((((uint64_t)ret_conv_14_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_14_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
ret_conv_14_ref = (uint64_t)ret_conv_14_var.inner;
if (ret_conv_14_var.is_owned) {
ret_conv_14_ref |= 1;
LDKRouteHint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_RouteHintHopZ val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
LDKRouteHintHop val_conv_14_conv;
val_conv_14_conv.inner = (void*)(val_conv_14 & (~1));
val_conv_14_conv.is_owned = (val_conv_14 & 1) || (val_conv_14 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_14_conv);
val_conv_14_conv = RouteHintHop_clone(&val_conv_14_conv);
val_constr.data[o] = val_conv_14_conv;
}
LDKRouteHintHop a_arg_conv_14_conv;
a_arg_conv_14_conv.inner = (void*)(a_arg_conv_14 & (~1));
a_arg_conv_14_conv.is_owned = (a_arg_conv_14 & 1) || (a_arg_conv_14 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_arg_conv_14_conv);
a_arg_conv_14_conv = RouteHintHop_clone(&a_arg_conv_14_conv);
a_arg_constr.data[o] = a_arg_conv_14_conv;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg) {
+ LDKRouteHint ret_var = RouteHint_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_RouteHint_clone_ptr(uint32_t arg) {
+ LDKRouteHint arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RouteHint_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_RouteHint_clone(uint32_t orig) {
LDKRouteHint orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRouteHint ret_var = RouteHint_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHint o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = RouteHint_hash(&o_conv);
return ret_val;
}
LDKRouteHint a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRouteHint b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RouteHint_eq(&a_conv, &b_conv);
return ret_val;
}
LDKRouteHint obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RouteHint_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKRouteHintHop this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RouteHintHop_free(this_obj_conv);
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), RouteHintHop_get_src_node_id(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = RouteHintHop_get_short_channel_id(&this_ptr_conv);
return ret_val;
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteHintHop_set_short_channel_id(&this_ptr_conv, val);
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees ret_var = RouteHintHop_get_fees(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = RoutingFees_clone(&val_conv);
RouteHintHop_set_fees(&this_ptr_conv, val_conv);
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = RouteHintHop_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteHintHop_set_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = RouteHintHop_get_htlc_minimum_msat(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = RouteHintHop_get_htlc_maximum_msat(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKRoutingFees fees_arg_conv;
fees_arg_conv.inner = (void*)(fees_arg & (~1));
fees_arg_conv.is_owned = (fees_arg & 1) || (fees_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(fees_arg_conv);
fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
void* htlc_minimum_msat_arg_ptr = (void*)(((uint64_t)htlc_minimum_msat_arg) & ~1);
CHECK_ACCESS(htlc_minimum_msat_arg_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg) {
+ LDKRouteHintHop ret_var = RouteHintHop_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_RouteHintHop_clone_ptr(uint32_t arg) {
+ LDKRouteHintHop arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RouteHintHop_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_RouteHintHop_clone(uint32_t orig) {
LDKRouteHintHop orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRouteHintHop ret_var = RouteHintHop_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHintHop o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = RouteHintHop_hash(&o_conv);
return ret_val;
}
LDKRouteHintHop a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRouteHintHop b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RouteHintHop_eq(&a_conv, &b_conv);
return ret_val;
}
LDKRouteHintHop obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RouteHintHop_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKRouteParameters params_conv;
params_conv.inner = (void*)(params & (~1));
params_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
LDKNetworkGraph network_conv;
network_conv.inner = (void*)(network & (~1));
network_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(network_conv);
LDKCVec_ChannelDetailsZ first_hops_constr;
LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL;
if (first_hops != 0) {
LDKChannelDetails first_hops_conv_16_conv;
first_hops_conv_16_conv.inner = (void*)(first_hops_conv_16 & (~1));
first_hops_conv_16_conv.is_owned = (first_hops_conv_16 & 1) || (first_hops_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_conv);
first_hops_constr.data[q] = first_hops_conv_16_conv;
}
first_hops_ptr = &first_hops_constr;
LDKScorer this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Scorer_free(this_obj_conv);
}
LDKScoringParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ScoringParameters_free(this_obj_conv);
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ScoringParameters_get_base_penalty_msat(&this_ptr_conv);
return ret_val;
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ScoringParameters_set_base_penalty_msat(&this_ptr_conv, val);
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ScoringParameters_get_failure_penalty_msat(&this_ptr_conv);
return ret_val;
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ScoringParameters_set_failure_penalty_msat(&this_ptr_conv, val);
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ScoringParameters_get_failure_penalty_half_life(&this_ptr_conv);
return ret_val;
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ScoringParameters_set_failure_penalty_half_life(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKScoringParameters obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ScoringParameters_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKScoringParameters params_conv;
params_conv.inner = (void*)(params & (~1));
params_conv.is_owned = (params & 1) || (params == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
// Warning: we need a move here but no clone is available for LDKScoringParameters
LDKScorer ret_var = Scorer_new(params_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKScorer this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
*ret_ret = Scorer_as_Score(&this_arg_conv);
return (uint64_t)ret_ret;
LDKScorer obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Scorer_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKFilesystemPersister this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
FilesystemPersister_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKFilesystemPersister this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKStr ret_str = FilesystemPersister_get_data_dir(&this_arg_conv);
jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
Str_free(ret_str);
LDKChannelManager manager_conv;
manager_conv.inner = (void*)(manager & (~1));
manager_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(manager_conv);
LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
*ret_conv = FilesystemPersister_persist_manager(data_dir_conv, &manager_conv);
return (uint64_t)ret_conv;
LDKFilesystemPersister this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* keys_manager_ptr = (void*)(((uint64_t)keys_manager) & ~1);
CHECK_ACCESS(keys_manager_ptr);
LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(keys_manager_ptr);
LDKFilesystemPersister this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPersist* ret_ret = MALLOC(sizeof(LDKPersist), "LDKPersist");
*ret_ret = FilesystemPersister_as_Persist(&this_arg_conv);
return (uint64_t)ret_ret;
LDKBackgroundProcessor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
BackgroundProcessor_free(this_obj_conv);
}
LDKChainMonitor chain_monitor_conv;
chain_monitor_conv.inner = (void*)(chain_monitor & (~1));
chain_monitor_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(chain_monitor_conv);
LDKChannelManager channel_manager_conv;
channel_manager_conv.inner = (void*)(channel_manager & (~1));
channel_manager_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_manager_conv);
LDKNetGraphMsgHandler net_graph_msg_handler_conv;
net_graph_msg_handler_conv.inner = (void*)(net_graph_msg_handler & (~1));
net_graph_msg_handler_conv.is_owned = (net_graph_msg_handler & 1) || (net_graph_msg_handler == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(net_graph_msg_handler_conv);
LDKPeerManager peer_manager_conv;
peer_manager_conv.inner = (void*)(peer_manager & (~1));
peer_manager_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(peer_manager_conv);
void* logger_ptr = (void*)(((uint64_t)logger) & ~1);
CHECK_ACCESS(logger_ptr);
LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKBackgroundProcessor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
// Warning: we need a move here but no clone is available for LDKBackgroundProcessor
LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
*ret_conv = BackgroundProcessor_join(this_arg_conv);
LDKBackgroundProcessor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
// Warning: we need a move here but no clone is available for LDKBackgroundProcessor
LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
*ret_conv = BackgroundProcessor_stop(this_arg_conv);
LDKInvoice this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Invoice_free(this_obj_conv);
}
LDKInvoice a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKInvoice b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = Invoice_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg) {
+ LDKInvoice ret_var = Invoice_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Invoice_clone_ptr(uint32_t arg) {
+ LDKInvoice arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Invoice_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Invoice_clone(uint32_t orig) {
LDKInvoice orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInvoice ret_var = Invoice_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKSignedRawInvoice this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
SignedRawInvoice_free(this_obj_conv);
}
LDKSignedRawInvoice a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKSignedRawInvoice b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = SignedRawInvoice_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg) {
+ LDKSignedRawInvoice ret_var = SignedRawInvoice_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_SignedRawInvoice_clone_ptr(uint32_t arg) {
+ LDKSignedRawInvoice arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = SignedRawInvoice_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_SignedRawInvoice_clone(uint32_t orig) {
LDKSignedRawInvoice orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKSignedRawInvoice ret_var = SignedRawInvoice_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RawInvoice_free(this_obj_conv);
}
LDKRawInvoice this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRawDataPart ret_var = RawInvoice_get_data(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRawDataPart val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = RawDataPart_clone(&val_conv);
RawInvoice_set_data(&this_ptr_conv, val_conv);
}
LDKRawInvoice a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRawInvoice b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RawInvoice_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg) {
+ LDKRawInvoice ret_var = RawInvoice_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_RawInvoice_clone_ptr(uint32_t arg) {
+ LDKRawInvoice arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RawInvoice_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_RawInvoice_clone(uint32_t orig) {
LDKRawInvoice orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRawInvoice ret_var = RawInvoice_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawDataPart this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RawDataPart_free(this_obj_conv);
}
LDKRawDataPart this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPositiveTimestamp ret_var = RawDataPart_get_timestamp(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawDataPart this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPositiveTimestamp val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = PositiveTimestamp_clone(&val_conv);
RawDataPart_set_timestamp(&this_ptr_conv, val_conv);
}
LDKRawDataPart a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRawDataPart b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RawDataPart_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg) {
+ LDKRawDataPart ret_var = RawDataPart_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_RawDataPart_clone_ptr(uint32_t arg) {
+ LDKRawDataPart arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RawDataPart_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_RawDataPart_clone(uint32_t orig) {
LDKRawDataPart orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRawDataPart ret_var = RawDataPart_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPositiveTimestamp this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
PositiveTimestamp_free(this_obj_conv);
}
LDKPositiveTimestamp a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKPositiveTimestamp b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = PositiveTimestamp_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg) {
+ LDKPositiveTimestamp ret_var = PositiveTimestamp_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_PositiveTimestamp_clone_ptr(uint32_t arg) {
+ LDKPositiveTimestamp arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = PositiveTimestamp_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_PositiveTimestamp_clone(uint32_t orig) {
LDKPositiveTimestamp orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPositiveTimestamp ret_var = PositiveTimestamp_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKSha256 this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Sha256_free(this_obj_conv);
}
+static inline uint64_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg) {
+ LDKSha256 ret_var = Sha256_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Sha256_clone_ptr(uint32_t arg) {
+ LDKSha256 arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Sha256_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Sha256_clone(uint32_t orig) {
LDKSha256 orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKSha256 ret_var = Sha256_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKSha256 o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = Sha256_hash(&o_conv);
return ret_val;
}
LDKSha256 a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKSha256 b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = Sha256_eq(&a_conv, &b_conv);
return ret_val;
}
LDKDescription this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Description_free(this_obj_conv);
}
+static inline uint64_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg) {
+ LDKDescription ret_var = Description_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Description_clone_ptr(uint32_t arg) {
+ LDKDescription arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Description_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Description_clone(uint32_t orig) {
LDKDescription orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKDescription ret_var = Description_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDescription o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = Description_hash(&o_conv);
return ret_val;
}
LDKDescription a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKDescription b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = Description_eq(&a_conv, &b_conv);
return ret_val;
}
LDKPayeePubKey this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
PayeePubKey_free(this_obj_conv);
}
LDKPayeePubKey this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), PayeePubKey_get_a(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKPayeePubKey this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg) {
+ LDKPayeePubKey ret_var = PayeePubKey_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_PayeePubKey_clone_ptr(uint32_t arg) {
+ LDKPayeePubKey arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = PayeePubKey_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_PayeePubKey_clone(uint32_t orig) {
LDKPayeePubKey orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPayeePubKey ret_var = PayeePubKey_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPayeePubKey o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = PayeePubKey_hash(&o_conv);
return ret_val;
}
LDKPayeePubKey a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKPayeePubKey b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = PayeePubKey_eq(&a_conv, &b_conv);
return ret_val;
}
LDKExpiryTime this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ExpiryTime_free(this_obj_conv);
}
+static inline uint64_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg) {
+ LDKExpiryTime ret_var = ExpiryTime_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ExpiryTime_clone_ptr(uint32_t arg) {
+ LDKExpiryTime arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ExpiryTime_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ExpiryTime_clone(uint32_t orig) {
LDKExpiryTime orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKExpiryTime ret_var = ExpiryTime_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKExpiryTime o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = ExpiryTime_hash(&o_conv);
return ret_val;
}
LDKExpiryTime a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKExpiryTime b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = ExpiryTime_eq(&a_conv, &b_conv);
return ret_val;
}
LDKMinFinalCltvExpiry this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
MinFinalCltvExpiry_free(this_obj_conv);
}
LDKMinFinalCltvExpiry this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = MinFinalCltvExpiry_get_a(&this_ptr_conv);
return ret_val;
}
LDKMinFinalCltvExpiry this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
MinFinalCltvExpiry_set_a(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t MinFinalCltvExpiry_clone_ptr(LDKMinFinalCltvExpiry *NONNULL_PTR arg) {
+ LDKMinFinalCltvExpiry ret_var = MinFinalCltvExpiry_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_MinFinalCltvExpiry_clone_ptr(uint32_t arg) {
+ LDKMinFinalCltvExpiry arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = MinFinalCltvExpiry_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_MinFinalCltvExpiry_clone(uint32_t orig) {
LDKMinFinalCltvExpiry orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKMinFinalCltvExpiry ret_var = MinFinalCltvExpiry_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKMinFinalCltvExpiry o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = MinFinalCltvExpiry_hash(&o_conv);
return ret_val;
}
LDKMinFinalCltvExpiry a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKMinFinalCltvExpiry b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = MinFinalCltvExpiry_eq(&a_conv, &b_conv);
return ret_val;
}
Fallback_free(this_ptr_conv);
}
+static inline uint64_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg) {
+ LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
+ *ret_copy = Fallback_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Fallback_clone_ptr(uint32_t arg) {
+ LDKFallback* arg_conv = (LDKFallback*)arg;
+ int64_t ret_val = Fallback_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Fallback_clone(uint32_t orig) {
LDKFallback* orig_conv = (LDKFallback*)orig;
LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
LDKInvoiceSignature this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InvoiceSignature_free(this_obj_conv);
}
+static inline uint64_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg) {
+ LDKInvoiceSignature ret_var = InvoiceSignature_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_InvoiceSignature_clone_ptr(uint32_t arg) {
+ LDKInvoiceSignature arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = InvoiceSignature_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_InvoiceSignature_clone(uint32_t orig) {
LDKInvoiceSignature orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInvoiceSignature ret_var = InvoiceSignature_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvoiceSignature a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKInvoiceSignature b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = InvoiceSignature_eq(&a_conv, &b_conv);
return ret_val;
}
LDKPrivateRoute this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
PrivateRoute_free(this_obj_conv);
}
+static inline uint64_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg) {
+ LDKPrivateRoute ret_var = PrivateRoute_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_PrivateRoute_clone_ptr(uint32_t arg) {
+ LDKPrivateRoute arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = PrivateRoute_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_PrivateRoute_clone(uint32_t orig) {
LDKPrivateRoute orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPrivateRoute ret_var = PrivateRoute_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPrivateRoute o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = PrivateRoute_hash(&o_conv);
return ret_val;
}
LDKPrivateRoute a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKPrivateRoute b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = PrivateRoute_eq(&a_conv, &b_conv);
return ret_val;
}
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
this_arg_conv = SignedRawInvoice_clone(&this_arg_conv);
LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
*ret_conv = SignedRawInvoice_into_parts(this_arg_conv);
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRawInvoice ret_var = SignedRawInvoice_raw_invoice(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *SignedRawInvoice_hash(&this_arg_conv), 32);
return ret_arr;
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInvoiceSignature ret_var = SignedRawInvoice_signature(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
*ret_conv = SignedRawInvoice_recover_payee_pub_key(&this_arg_conv);
return (uint64_t)ret_conv;
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = SignedRawInvoice_check_signature(&this_arg_conv);
return ret_val;
}
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), RawInvoice_hash(&this_arg_conv).data, 32);
return ret_arr;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKSha256 ret_var = RawInvoice_payment_hash(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKDescription ret_var = RawInvoice_description(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPayeePubKey ret_var = RawInvoice_payee_pub_key(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKSha256 ret_var = RawInvoice_description_hash(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKExpiryTime ret_var = RawInvoice_expiry_time(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKMinFinalCltvExpiry ret_var = RawInvoice_min_final_cltv_expiry(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), RawInvoice_payment_secret(&this_arg_conv).data, 32);
return ret_arr;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInvoiceFeatures ret_var = RawInvoice_features(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_PrivateRouteZ ret_var = RawInvoice_private_routes(&this_arg_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_14_ref = 0;
CHECK((((uint64_t)ret_conv_14_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_14_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
ret_conv_14_ref = (uint64_t)ret_conv_14_var.inner;
if (ret_conv_14_var.is_owned) {
ret_conv_14_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = RawInvoice_amount_pico_btc(&this_arg_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
uint32_t ret_conv = LDKCurrency_to_js(RawInvoice_currency(&this_arg_conv));
return ret_conv;
}
LDKPositiveTimestamp this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = PositiveTimestamp_as_unix_timestamp(&this_arg_conv);
return ret_val;
}
LDKPositiveTimestamp this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = PositiveTimestamp_as_time(&this_arg_conv);
return ret_val;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
this_arg_conv = Invoice_clone(&this_arg_conv);
LDKSignedRawInvoice ret_var = Invoice_into_signed_raw(this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
*ret_conv = Invoice_check_signature(&this_arg_conv);
return (uint64_t)ret_conv;
LDKSignedRawInvoice signed_invoice_conv;
signed_invoice_conv.inner = (void*)(signed_invoice & (~1));
signed_invoice_conv.is_owned = (signed_invoice & 1) || (signed_invoice == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(signed_invoice_conv);
signed_invoice_conv = SignedRawInvoice_clone(&signed_invoice_conv);
LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
*ret_conv = Invoice_from_signed(signed_invoice_conv);
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = Invoice_timestamp(&this_arg_conv);
return ret_val;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *Invoice_payment_hash(&this_arg_conv), 32);
return ret_arr;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), Invoice_payee_pub_key(&this_arg_conv).compressed_form, 33);
return ret_arr;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *Invoice_payment_secret(&this_arg_conv), 32);
return ret_arr;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInvoiceFeatures ret_var = Invoice_features(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), Invoice_recover_payee_pub_key(&this_arg_conv).compressed_form, 33);
return ret_arr;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = Invoice_expiry_time(&this_arg_conv);
return ret_val;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = Invoice_is_expired(&this_arg_conv);
return ret_val;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = Invoice_min_final_cltv_expiry(&this_arg_conv);
return ret_val;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_PrivateRouteZ ret_var = Invoice_private_routes(&this_arg_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_14_ref = 0;
CHECK((((uint64_t)ret_conv_14_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_14_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
ret_conv_14_ref = (uint64_t)ret_conv_14_var.inner;
if (ret_conv_14_var.is_owned) {
ret_conv_14_ref |= 1;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_RouteHintZ ret_var = Invoice_route_hints(&this_arg_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_11_ref = 0;
CHECK((((uint64_t)ret_conv_11_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_11_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_11_var);
ret_conv_11_ref = (uint64_t)ret_conv_11_var.inner;
if (ret_conv_11_var.is_owned) {
ret_conv_11_ref |= 1;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
uint32_t ret_conv = LDKCurrency_to_js(Invoice_currency(&this_arg_conv));
return ret_conv;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = Invoice_amount_milli_satoshis(&this_arg_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKDescription this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
this_arg_conv = Description_clone(&this_arg_conv);
LDKStr ret_str = Description_into_inner(this_arg_conv);
jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
LDKExpiryTime this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = ExpiryTime_as_seconds(&this_arg_conv);
return ret_val;
}
LDKExpiryTime this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = ExpiryTime_as_duration(&this_arg_conv);
return ret_val;
}
LDKRouteHint hops_conv;
hops_conv.inner = (void*)(hops & (~1));
hops_conv.is_owned = (hops & 1) || (hops == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(hops_conv);
hops_conv = RouteHint_clone(&hops_conv);
LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
*ret_conv = PrivateRoute_new(hops_conv);
LDKPrivateRoute this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
this_arg_conv = PrivateRoute_clone(&this_arg_conv);
LDKRouteHint ret_var = PrivateRoute_into_inner(this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
SignOrCreationError_free(this_ptr_conv);
}
+static inline uint64_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg) {
+ LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
+ *ret_copy = SignOrCreationError_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_SignOrCreationError_clone_ptr(uint32_t arg) {
+ LDKSignOrCreationError* arg_conv = (LDKSignOrCreationError*)arg;
+ int64_t ret_val = SignOrCreationError_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_SignOrCreationError_clone(uint32_t orig) {
LDKSignOrCreationError* orig_conv = (LDKSignOrCreationError*)orig;
LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
LDKInvoicePayer this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InvoicePayer_free(this_obj_conv);
}
LDKRetryAttempts this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RetryAttempts_free(this_obj_conv);
}
LDKRetryAttempts this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = RetryAttempts_get_a(&this_ptr_conv);
return ret_val;
}
LDKRetryAttempts this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RetryAttempts_set_a(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RetryAttempts_clone_ptr(LDKRetryAttempts *NONNULL_PTR arg) {
+ LDKRetryAttempts ret_var = RetryAttempts_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_RetryAttempts_clone_ptr(uint32_t arg) {
+ LDKRetryAttempts arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RetryAttempts_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_RetryAttempts_clone(uint32_t orig) {
LDKRetryAttempts orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRetryAttempts ret_var = RetryAttempts_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRetryAttempts a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRetryAttempts b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RetryAttempts_eq(&a_conv, &b_conv);
return ret_val;
}
LDKRetryAttempts o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = RetryAttempts_hash(&o_conv);
return ret_val;
}
PaymentError_free(this_ptr_conv);
}
+static inline uint64_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg) {
+ LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
+ *ret_copy = PaymentError_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_PaymentError_clone_ptr(uint32_t arg) {
+ LDKPaymentError* arg_conv = (LDKPaymentError*)arg;
+ int64_t ret_val = PaymentError_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_PaymentError_clone(uint32_t orig) {
LDKPaymentError* orig_conv = (LDKPaymentError*)orig;
LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
LDKLightningError a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = LightningError_clone(&a_conv);
LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
*ret_copy = PaymentError_routing(a_conv);
LDKLockableScore scorer_conv;
scorer_conv.inner = (void*)(scorer & (~1));
scorer_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(scorer_conv);
void* logger_ptr = (void*)(((uint64_t)logger) & ~1);
CHECK_ACCESS(logger_ptr);
LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
LDKRetryAttempts retry_attempts_conv;
retry_attempts_conv.inner = (void*)(retry_attempts & (~1));
retry_attempts_conv.is_owned = (retry_attempts & 1) || (retry_attempts == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(retry_attempts_conv);
retry_attempts_conv = RetryAttempts_clone(&retry_attempts_conv);
LDKInvoicePayer ret_var = InvoicePayer_new(payer_conv, router_conv, &scorer_conv, logger_conv, event_handler_conv, retry_attempts_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvoicePayer this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInvoice invoice_conv;
invoice_conv.inner = (void*)(invoice & (~1));
invoice_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
*ret_conv = InvoicePayer_pay_invoice(&this_arg_conv, &invoice_conv);
return (uint64_t)ret_conv;
LDKInvoicePayer this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInvoice invoice_conv;
invoice_conv.inner = (void*)(invoice & (~1));
invoice_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
*ret_conv = InvoicePayer_pay_zero_value_invoice(&this_arg_conv, &invoice_conv, amount_msats);
return (uint64_t)ret_conv;
LDKInvoicePayer this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char payment_hash_arr[32];
CHECK(*((uint32_t*)payment_hash) == 32);
memcpy(payment_hash_arr, (uint8_t*)(payment_hash + 4), 32);
LDKInvoicePayer this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKEventHandler* ret_ret = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
*ret_ret = InvoicePayer_as_EventHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager channelmanager_conv;
channelmanager_conv.inner = (void*)(channelmanager & (~1));
channelmanager_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
void* keys_manager_ptr = (void*)(((uint64_t)keys_manager) & ~1);
CHECK_ACCESS(keys_manager_ptr);
LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(keys_manager_ptr);
LDKDefaultRouter this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DefaultRouter_free(this_obj_conv);
}
LDKNetworkGraph network_graph_conv;
network_graph_conv.inner = (void*)(network_graph & (~1));
network_graph_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
void* logger_ptr = (void*)(((uint64_t)logger) & ~1);
CHECK_ACCESS(logger_ptr);
LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDefaultRouter this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRouter* ret_ret = MALLOC(sizeof(LDKRouter), "LDKRouter");
*ret_ret = DefaultRouter_as_Router(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPayer* ret_ret = MALLOC(sizeof(LDKPayer), "LDKPayer");
*ret_ret = ChannelManager_as_Payer(&this_arg_conv);
return (uint64_t)ret_ret;
LDKInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
LDKStr ret_str = Invoice_to_str(&o_conv);
jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
Str_free(ret_str);
LDKSignedRawInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
LDKStr ret_str = SignedRawInvoice_to_str(&o_conv);
jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
Str_free(ret_str);
#define DO_ASSERT(a) (void)(a)
#define CHECK(a)
#define CHECK_ACCESS(p)
+#define CHECK_INNER_FIELD_ACCESS_OR_NULL(v)
// We assume that CVec_u8Z and u8slice are the same size and layout (and thus pointers to the two can be mixed)
_Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKu8slice), "Vec<u8> and [u8] need to have been mapped identically");
default: abort();
}
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_u8Z_new(int8_tArray elems) {
- LDKCVec_u8Z *ret = MALLOC(sizeof(LDKCVec_u8Z), "LDKCVec_u8Z");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(uint8_t) * ret->datalen, "LDKCVec_u8Z Data");
- int8_t *java_elems = (int8_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- ret->data[i] = java_elems[i];
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_u8Z CVec_u8Z_clone(const LDKCVec_u8Z *orig) {
LDKCVec_u8Z ret = { .data = MALLOC(sizeof(int8_t) * orig->datalen, "LDKCVec_u8Z clone bytes"), .datalen = orig->datalen };
memcpy(ret.data, orig->data, sizeof(int8_t) * ret.datalen);
return ret_val;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_SecretKeyErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_SecretKeyErrorZ*)arg)->result_ok;
-}
int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_SecretKeyErrorZ_get_ok(uint32_t arg) {
LDKCResult_SecretKeyErrorZ *val = (LDKCResult_SecretKeyErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint32_t err_conv = LDKSecp256k1Error_to_js((*val->contents.err));
return err_conv;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_PublicKeyErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_PublicKeyErrorZ*)arg)->result_ok;
-}
int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_PublicKeyErrorZ_get_ok(uint32_t arg) {
LDKCResult_PublicKeyErrorZ *val = (LDKCResult_PublicKeyErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint32_t err_conv = LDKSecp256k1Error_to_js((*val->contents.err));
return err_conv;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_TxCreationKeysDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_TxCreationKeysDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_TxCreationKeysDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_TxCreationKeysDecodeErrorZ *val = (LDKCResult_TxCreationKeysDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelPublicKeysDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ChannelPublicKeysDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelPublicKeysDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ChannelPublicKeysDecodeErrorZ *val = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_TxCreationKeysErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_TxCreationKeysErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_TxCreationKeysErrorZ_get_ok(uint32_t arg) {
LDKCResult_TxCreationKeysErrorZ *val = (LDKCResult_TxCreationKeysErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
default: abort();
}
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *val = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *val = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelTransactionParametersDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ChannelTransactionParametersDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelTransactionParametersDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ChannelTransactionParametersDecodeErrorZ *val = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_HolderCommitmentTransactionDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_HolderCommitmentTransactionDecodeErrorZ *val = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_BuiltCommitmentTransactionDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *val = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_TrustedClosingTransactionNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_TrustedClosingTransactionNoneZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_TrustedClosingTransactionNoneZ_get_ok(uint32_t arg) {
LDKCResult_TrustedClosingTransactionNoneZ *val = (LDKCResult_TrustedClosingTransactionNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
CHECK(!val->result_ok);
return *val->contents.err;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_CommitmentTransactionDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_CommitmentTransactionDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_CommitmentTransactionDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_CommitmentTransactionDecodeErrorZ *val = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_TrustedCommitmentTransactionNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_TrustedCommitmentTransactionNoneZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_TrustedCommitmentTransactionNoneZ_get_ok(uint32_t arg) {
LDKCResult_TrustedCommitmentTransactionNoneZ *val = (LDKCResult_TrustedCommitmentTransactionNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
CHECK(!val->result_ok);
return *val->contents.err;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_CVec_SignatureZNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_CVec_SignatureZNoneZ*)arg)->result_ok;
-}
ptrArray __attribute__((visibility("default"))) TS_LDKCResult_CVec_SignatureZNoneZ_get_ok(uint32_t arg) {
LDKCResult_CVec_SignatureZNoneZ *val = (LDKCResult_CVec_SignatureZNoneZ*)(arg & ~1);
CHECK(val->result_ok);
CHECK(!val->result_ok);
return *val->contents.err;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ShutdownScriptDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ShutdownScriptDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ShutdownScriptDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ShutdownScriptDecodeErrorZ *val = (LDKCResult_ShutdownScriptDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ShutdownScriptInvalidShutdownScriptZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(uint32_t arg) {
LDKCResult_ShutdownScriptInvalidShutdownScriptZ *val = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NoneErrorZ*)arg)->result_ok;
-}
void __attribute__((visibility("default"))) TS_LDKCResult_NoneErrorZ_get_ok(uint32_t arg) {
LDKCResult_NoneErrorZ *val = (LDKCResult_NoneErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint32_t err_conv = LDKIOError_to_js((*val->contents.err));
return err_conv;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_RouteHopDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_RouteHopDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RouteHopDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_RouteHopDecodeErrorZ *val = (LDKCResult_RouteHopDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_RouteHopZ_new(uint32_tArray elems) {
- LDKCVec_RouteHopZ *ret = MALLOC(sizeof(LDKCVec_RouteHopZ), "LDKCVec_RouteHopZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKRouteHop) * ret->datalen, "LDKCVec_RouteHopZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKRouteHop arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = RouteHop_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_RouteHopZ CVec_RouteHopZ_clone(const LDKCVec_RouteHopZ *orig) {
LDKCVec_RouteHopZ ret = { .data = MALLOC(sizeof(LDKRouteHop) * orig->datalen, "LDKCVec_RouteHopZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_RouteDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_RouteDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RouteDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_RouteDecodeErrorZ *val = (LDKCResult_RouteDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_RouteParametersDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_RouteParametersDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RouteParametersDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_RouteParametersDecodeErrorZ *val = (LDKCResult_RouteParametersDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_RouteHintZ_new(uint32_tArray elems) {
- LDKCVec_RouteHintZ *ret = MALLOC(sizeof(LDKCVec_RouteHintZ), "LDKCVec_RouteHintZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKRouteHint) * ret->datalen, "LDKCVec_RouteHintZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKRouteHint arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = RouteHint_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_RouteHintZ CVec_RouteHintZ_clone(const LDKCVec_RouteHintZ *orig) {
LDKCVec_RouteHintZ ret = { .data = MALLOC(sizeof(LDKRouteHint) * orig->datalen, "LDKCVec_RouteHintZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
default: abort();
}
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_PayeeDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_PayeeDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PayeeDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_PayeeDecodeErrorZ *val = (LDKCResult_PayeeDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_RouteHintHopZ_new(uint32_tArray elems) {
- LDKCVec_RouteHintHopZ *ret = MALLOC(sizeof(LDKCVec_RouteHintHopZ), "LDKCVec_RouteHintHopZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKRouteHintHop) * ret->datalen, "LDKCVec_RouteHintHopZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKRouteHintHop arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = RouteHintHop_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_RouteHintHopZ CVec_RouteHintHopZ_clone(const LDKCVec_RouteHintHopZ *orig) {
LDKCVec_RouteHintHopZ ret = { .data = MALLOC(sizeof(LDKRouteHintHop) * orig->datalen, "LDKCVec_RouteHintHopZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_RouteHintDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_RouteHintDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RouteHintDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_RouteHintDecodeErrorZ *val = (LDKCResult_RouteHintDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_RouteHintHopDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_RouteHintHopDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RouteHintHopDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_RouteHintHopDecodeErrorZ *val = (LDKCResult_RouteHintHopDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_ChannelDetailsZ_new(uint32_tArray elems) {
- LDKCVec_ChannelDetailsZ *ret = MALLOC(sizeof(LDKCVec_ChannelDetailsZ), "LDKCVec_ChannelDetailsZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKChannelDetails) * ret->datalen, "LDKCVec_ChannelDetailsZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKChannelDetails arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = ChannelDetails_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_ChannelDetailsZ CVec_ChannelDetailsZ_clone(const LDKCVec_ChannelDetailsZ *orig) {
LDKCVec_ChannelDetailsZ ret = { .data = MALLOC(sizeof(LDKChannelDetails) * orig->datalen, "LDKCVec_ChannelDetailsZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_RouteLightningErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_RouteLightningErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RouteLightningErrorZ_get_ok(uint32_t arg) {
LDKCResult_RouteLightningErrorZ *val = (LDKCResult_RouteLightningErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_TxOutAccessErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_TxOutAccessErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_TxOutAccessErrorZ_get_ok(uint32_t arg) {
LDKCResult_TxOutAccessErrorZ *val = (LDKCResult_TxOutAccessErrorZ*)(arg & ~1);
CHECK(val->result_ok);
return ret_arr;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_usizeTransactionZZ_new(uint32_tArray elems) {
- LDKCVec_C2Tuple_usizeTransactionZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_usizeTransactionZZ), "LDKCVec_C2Tuple_usizeTransactionZZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ) * ret->datalen, "LDKCVec_C2Tuple_usizeTransactionZZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_usizeTransactionZ arr_elem_conv = *(LDKC2Tuple_usizeTransactionZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_usizeTransactionZZ CVec_C2Tuple_usizeTransactionZZ_clone(const LDKCVec_C2Tuple_usizeTransactionZZ *orig) {
LDKCVec_C2Tuple_usizeTransactionZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ) * orig->datalen, "LDKCVec_C2Tuple_usizeTransactionZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneChannelMonitorUpdateErrZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NoneChannelMonitorUpdateErrZ*)arg)->result_ok;
-}
void __attribute__((visibility("default"))) TS_LDKCResult_NoneChannelMonitorUpdateErrZ_get_ok(uint32_t arg) {
LDKCResult_NoneChannelMonitorUpdateErrZ *val = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t htlc_event_ref = 0;
CHECK((((uint64_t)htlc_event_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&htlc_event_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_event_var);
htlc_event_ref = (uint64_t)htlc_event_var.inner & ~1;
return 0 /* LDKMonitorEvent - HTLCEvent */; (void) htlc_event_ref;
}
uint64_t commitment_tx_confirmed_ref = 0;
CHECK((((uint64_t)commitment_tx_confirmed_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&commitment_tx_confirmed_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_confirmed_var);
commitment_tx_confirmed_ref = (uint64_t)commitment_tx_confirmed_var.inner & ~1;
return 0 /* LDKMonitorEvent - CommitmentTxConfirmed */; (void) commitment_tx_confirmed_ref;
}
uint64_t funding_txo_ref = 0;
CHECK((((uint64_t)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
funding_txo_ref = (uint64_t)funding_txo_var.inner & ~1;
return 0 /* LDKMonitorEvent - UpdateCompleted */; (void) funding_txo_ref; (void) obj->update_completed.monitor_update_id;
}
uint64_t update_failed_ref = 0;
CHECK((((uint64_t)update_failed_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_failed_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_failed_var);
update_failed_ref = (uint64_t)update_failed_var.inner & ~1;
return 0 /* LDKMonitorEvent - UpdateFailed */; (void) update_failed_ref;
}
default: abort();
}
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_MonitorEventZ_new(uint32_tArray elems) {
- LDKCVec_MonitorEventZ *ret = MALLOC(sizeof(LDKCVec_MonitorEventZ), "LDKCVec_MonitorEventZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKMonitorEvent) * ret->datalen, "LDKCVec_MonitorEventZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKMonitorEvent arr_elem_conv = *(LDKMonitorEvent*)(arr_elem_ptr);
- arr_elem_conv = MonitorEvent_clone((LDKMonitorEvent*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_MonitorEventZ CVec_MonitorEventZ_clone(const LDKCVec_MonitorEventZ *orig) {
LDKCVec_MonitorEventZ ret = { .data = MALLOC(sizeof(LDKMonitorEvent) * orig->datalen, "LDKCVec_MonitorEventZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
default: abort();
}
}
+uint32_t __attribute__((visibility("default"))) TS_LDKClosureReason_ref_from_ptr(uint32_t ptr) {
+ LDKClosureReason *obj = (LDKClosureReason*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKClosureReason_CounterpartyForceClosed: {
+ LDKStr peer_msg_str = obj->counterparty_force_closed.peer_msg;
+ jstring peer_msg_conv = str_ref_to_ts(peer_msg_str.chars, peer_msg_str.len);
+ return 0 /* LDKClosureReason - CounterpartyForceClosed */; (void) peer_msg_conv;
+ }
+ case LDKClosureReason_HolderForceClosed: {
+ return 0 /* LDKClosureReason - HolderForceClosed */;
+ }
+ case LDKClosureReason_CooperativeClosure: {
+ return 0 /* LDKClosureReason - CooperativeClosure */;
+ }
+ case LDKClosureReason_CommitmentTxConfirmed: {
+ return 0 /* LDKClosureReason - CommitmentTxConfirmed */;
+ }
+ case LDKClosureReason_ProcessingError: {
+ LDKStr err_str = obj->processing_error.err;
+ jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
+ return 0 /* LDKClosureReason - ProcessingError */; (void) err_conv;
+ }
+ case LDKClosureReason_DisconnectedPeer: {
+ return 0 /* LDKClosureReason - DisconnectedPeer */;
+ }
+ case LDKClosureReason_OutdatedChannelManager: {
+ return 0 /* LDKClosureReason - OutdatedChannelManager */;
+ }
+ default: abort();
+ }
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCOption_ClosureReasonZ_ref_from_ptr(uint32_t ptr) {
+ LDKCOption_ClosureReasonZ *obj = (LDKCOption_ClosureReasonZ*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKCOption_ClosureReasonZ_Some: {
+ uint64_t some_ref = ((uint64_t)&obj->some) | 1;
+ return 0 /* LDKCOption_ClosureReasonZ - Some */; (void) some_ref;
+ }
+ case LDKCOption_ClosureReasonZ_None: {
+ return 0 /* LDKCOption_ClosureReasonZ - None */;
+ }
+ default: abort();
+ }
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCResult_COption_ClosureReasonZDecodeErrorZ_get_ok(uint32_t arg) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ *val = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(arg & ~1);
+ CHECK(val->result_ok);
+ uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
+ return res_ref;
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCResult_COption_ClosureReasonZDecodeErrorZ_get_err(uint32_t arg) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ *val = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(arg & ~1);
+ CHECK(!val->result_ok);
+ LDKDecodeError err_var = (*val->contents.err);
+ uint64_t err_ref = 0;
+ CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
+ err_ref = (uint64_t)err_var.inner & ~1;
+ return err_ref;
+}
uint32_t __attribute__((visibility("default"))) TS_LDKNetworkUpdate_ref_from_ptr(uint32_t ptr) {
LDKNetworkUpdate *obj = (LDKNetworkUpdate*)(ptr & ~1);
switch(obj->tag) {
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKNetworkUpdate - ChannelUpdateMessage */; (void) msg_ref;
}
uint64_t outpoint_ref = 0;
CHECK((((uint64_t)outpoint_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&outpoint_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_var);
outpoint_ref = (uint64_t)outpoint_var.inner & ~1;
uint64_t output_ref = ((uint64_t)&obj->static_output.output) | 1;
return 0 /* LDKSpendableOutputDescriptor - StaticOutput */; (void) outpoint_ref; (void) (uint64_t)output_ref;
uint64_t delayed_payment_output_ref = 0;
CHECK((((uint64_t)delayed_payment_output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&delayed_payment_output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(delayed_payment_output_var);
delayed_payment_output_ref = (uint64_t)delayed_payment_output_var.inner & ~1;
return 0 /* LDKSpendableOutputDescriptor - DelayedPaymentOutput */; (void) delayed_payment_output_ref;
}
uint64_t static_payment_output_ref = 0;
CHECK((((uint64_t)static_payment_output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&static_payment_output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(static_payment_output_var);
static_payment_output_ref = (uint64_t)static_payment_output_var.inner & ~1;
return 0 /* LDKSpendableOutputDescriptor - StaticPaymentOutput */; (void) static_payment_output_ref;
}
default: abort();
}
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_SpendableOutputDescriptorZ_new(uint32_tArray elems) {
- LDKCVec_SpendableOutputDescriptorZ *ret = MALLOC(sizeof(LDKCVec_SpendableOutputDescriptorZ), "LDKCVec_SpendableOutputDescriptorZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKSpendableOutputDescriptor) * ret->datalen, "LDKCVec_SpendableOutputDescriptorZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKSpendableOutputDescriptor arr_elem_conv = *(LDKSpendableOutputDescriptor*)(arr_elem_ptr);
- arr_elem_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_SpendableOutputDescriptorZ CVec_SpendableOutputDescriptorZ_clone(const LDKCVec_SpendableOutputDescriptorZ *orig) {
LDKCVec_SpendableOutputDescriptorZ ret = { .data = MALLOC(sizeof(LDKSpendableOutputDescriptor) * orig->datalen, "LDKCVec_SpendableOutputDescriptorZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
+uint32_t __attribute__((visibility("default"))) TS_LDKPaymentPurpose_ref_from_ptr(uint32_t ptr) {
+ LDKPaymentPurpose *obj = (LDKPaymentPurpose*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKPaymentPurpose_InvoicePayment: {
+ int8_tArray payment_preimage_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(payment_preimage_arr + 4), obj->invoice_payment.payment_preimage.data, 32);
+ int8_tArray payment_secret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(payment_secret_arr + 4), obj->invoice_payment.payment_secret.data, 32);
+ return 0 /* LDKPaymentPurpose - InvoicePayment */; (void) payment_preimage_arr; (void) payment_secret_arr; (void) obj->invoice_payment.user_payment_id;
+ }
+ case LDKPaymentPurpose_SpontaneousPayment: {
+ int8_tArray spontaneous_payment_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(spontaneous_payment_arr + 4), obj->spontaneous_payment.data, 32);
+ return 0 /* LDKPaymentPurpose - SpontaneousPayment */; (void) spontaneous_payment_arr;
+ }
+ default: abort();
+ }
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKEvent_ref_from_ptr(uint32_t ptr) {
+ LDKEvent *obj = (LDKEvent*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKEvent_FundingGenerationReady: {
+ int8_tArray temporary_channel_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(temporary_channel_id_arr + 4), obj->funding_generation_ready.temporary_channel_id.data, 32);
+ LDKCVec_u8Z output_script_var = obj->funding_generation_ready.output_script;
+ int8_tArray output_script_arr = init_arr(output_script_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(output_script_arr + 4), output_script_var.data, output_script_var.datalen);
+ return 0 /* LDKEvent - FundingGenerationReady */; (void) temporary_channel_id_arr; (void) obj->funding_generation_ready.channel_value_satoshis; (void) output_script_arr; (void) obj->funding_generation_ready.user_channel_id;
+ }
+ case LDKEvent_PaymentReceived: {
+ int8_tArray payment_hash_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(payment_hash_arr + 4), obj->payment_received.payment_hash.data, 32);
+ uint64_t purpose_ref = ((uint64_t)&obj->payment_received.purpose) | 1;
+ return 0 /* LDKEvent - PaymentReceived */; (void) payment_hash_arr; (void) obj->payment_received.amt; (void) purpose_ref;
+ }
+ case LDKEvent_PaymentSent: {
+ int8_tArray payment_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(payment_id_arr + 4), obj->payment_sent.payment_id.data, 32);
+ int8_tArray payment_preimage_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(payment_preimage_arr + 4), obj->payment_sent.payment_preimage.data, 32);
+ int8_tArray payment_hash_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(payment_hash_arr + 4), obj->payment_sent.payment_hash.data, 32);
+ uint64_t fee_paid_msat_ref = ((uint64_t)&obj->payment_sent.fee_paid_msat) | 1;
+ return 0 /* LDKEvent - PaymentSent */; (void) payment_id_arr; (void) payment_preimage_arr; (void) payment_hash_arr; (void) fee_paid_msat_ref;
+ }
+ case LDKEvent_PaymentPathFailed: {
+ int8_tArray payment_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(payment_id_arr + 4), obj->payment_path_failed.payment_id.data, 32);
+ int8_tArray payment_hash_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(payment_hash_arr + 4), obj->payment_path_failed.payment_hash.data, 32);
+ uint64_t network_update_ref = ((uint64_t)&obj->payment_path_failed.network_update) | 1;
+ LDKCVec_RouteHopZ path_var = obj->payment_path_failed.path;
+ uint32_tArray path_arr = NULL;
+ path_arr = init_arr(path_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
+ uint32_t *path_arr_ptr = (uint32_t*)(path_arr + 4);
+ for (size_t k = 0; k < path_var.datalen; k++) {
+ LDKRouteHop path_conv_10_var = path_var.data[k];
+ uint64_t path_conv_10_ref = 0;
+ CHECK((((uint64_t)path_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&path_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
+ path_conv_10_ref = (uint64_t)path_conv_10_var.inner & ~1;
+ path_arr_ptr[k] = path_conv_10_ref;
+ }
+
+ uint64_t short_channel_id_ref = ((uint64_t)&obj->payment_path_failed.short_channel_id) | 1;
+ LDKRouteParameters retry_var = obj->payment_path_failed.retry;
+ uint64_t retry_ref = 0;
+ if ((uint64_t)retry_var.inner > 4096) {
+ CHECK((((uint64_t)retry_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&retry_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(retry_var);
+ retry_ref = (uint64_t)retry_var.inner & ~1;
+ }
+ return 0 /* LDKEvent - PaymentPathFailed */; (void) payment_id_arr; (void) payment_hash_arr; (void) obj->payment_path_failed.rejected_by_dest; (void) network_update_ref; (void) obj->payment_path_failed.all_paths_failed; (void) path_arr; (void) short_channel_id_ref; (void) retry_ref;
+ }
+ case LDKEvent_PendingHTLCsForwardable: {
+ return 0 /* LDKEvent - PendingHTLCsForwardable */; (void) obj->pending_htl_cs_forwardable.time_forwardable;
+ }
+ case LDKEvent_SpendableOutputs: {
+ LDKCVec_SpendableOutputDescriptorZ outputs_var = obj->spendable_outputs.outputs;
+ uint32_tArray outputs_arr = NULL;
+ outputs_arr = init_arr(outputs_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
+ uint32_t *outputs_arr_ptr = (uint32_t*)(outputs_arr + 4);
+ for (size_t b = 0; b < outputs_var.datalen; b++) {
+ uint64_t outputs_conv_27_ref = ((uint64_t)&outputs_var.data[b]) | 1;
+ outputs_arr_ptr[b] = outputs_conv_27_ref;
+ }
+
+ return 0 /* LDKEvent - SpendableOutputs */; (void) outputs_arr;
+ }
+ case LDKEvent_PaymentForwarded: {
+ uint64_t fee_earned_msat_ref = ((uint64_t)&obj->payment_forwarded.fee_earned_msat) | 1;
+ return 0 /* LDKEvent - PaymentForwarded */; (void) fee_earned_msat_ref; (void) obj->payment_forwarded.claim_from_onchain_tx;
+ }
+ case LDKEvent_ChannelClosed: {
+ int8_tArray channel_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(channel_id_arr + 4), obj->channel_closed.channel_id.data, 32);
+ uint64_t reason_ref = ((uint64_t)&obj->channel_closed.reason) | 1;
+ return 0 /* LDKEvent - ChannelClosed */; (void) channel_id_arr; (void) obj->channel_closed.user_channel_id; (void) reason_ref;
+ }
+ case LDKEvent_DiscardFunding: {
+ int8_tArray channel_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(channel_id_arr + 4), obj->discard_funding.channel_id.data, 32);
+ LDKTransaction transaction_var = obj->discard_funding.transaction;
+ int8_tArray transaction_arr = init_arr(transaction_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(transaction_arr + 4), transaction_var.data, transaction_var.datalen);
+ return 0 /* LDKEvent - DiscardFunding */; (void) channel_id_arr; (void) transaction_arr;
+ }
+ default: abort();
+ }
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCOption_EventZ_ref_from_ptr(uint32_t ptr) {
+ LDKCOption_EventZ *obj = (LDKCOption_EventZ*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKCOption_EventZ_Some: {
+ uint64_t some_ref = ((uint64_t)&obj->some) | 1;
+ return 0 /* LDKCOption_EventZ - Some */; (void) some_ref;
+ }
+ case LDKCOption_EventZ_None: {
+ return 0 /* LDKCOption_EventZ - None */;
+ }
+ default: abort();
+ }
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCResult_COption_EventZDecodeErrorZ_get_ok(uint32_t arg) {
+ LDKCResult_COption_EventZDecodeErrorZ *val = (LDKCResult_COption_EventZDecodeErrorZ*)(arg & ~1);
+ CHECK(val->result_ok);
+ uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
+ return res_ref;
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCResult_COption_EventZDecodeErrorZ_get_err(uint32_t arg) {
+ LDKCResult_COption_EventZDecodeErrorZ *val = (LDKCResult_COption_EventZDecodeErrorZ*)(arg & ~1);
+ CHECK(!val->result_ok);
+ LDKDecodeError err_var = (*val->contents.err);
+ uint64_t err_ref = 0;
+ CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
+ err_ref = (uint64_t)err_var.inner & ~1;
+ return err_ref;
+}
uint32_t __attribute__((visibility("default"))) TS_LDKErrorAction_ref_from_ptr(uint32_t ptr) {
LDKErrorAction *obj = (LDKErrorAction*)(ptr & ~1);
switch(obj->tag) {
if ((uint64_t)msg_var.inner > 4096) {
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
}
return 0 /* LDKErrorAction - DisconnectPeer */; (void) msg_ref;
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKErrorAction - SendErrorMessage */; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendAcceptChannel */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendOpenChannel */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendFundingCreated */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendFundingSigned */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendFundingLocked */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendAnnouncementSignatures */; (void) node_id_arr; (void) msg_ref;
}
uint64_t updates_ref = 0;
CHECK((((uint64_t)updates_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&updates_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_var);
updates_ref = (uint64_t)updates_var.inner & ~1;
return 0 /* LDKMessageSendEvent - UpdateHTLCs */; (void) node_id_arr; (void) updates_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendRevokeAndACK */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendClosingSigned */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendShutdown */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendChannelReestablish */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
LDKChannelUpdate update_msg_var = obj->broadcast_channel_announcement.update_msg;
uint64_t update_msg_ref = 0;
CHECK((((uint64_t)update_msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_var);
update_msg_ref = (uint64_t)update_msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - BroadcastChannelAnnouncement */; (void) msg_ref; (void) update_msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - BroadcastNodeAnnouncement */; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - BroadcastChannelUpdate */; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendChannelUpdate */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendChannelRangeQuery */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendShortIdsQuery */; (void) node_id_arr; (void) msg_ref;
}
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner & ~1;
return 0 /* LDKMessageSendEvent - SendReplyChannelRange */; (void) node_id_arr; (void) msg_ref;
}
default: abort();
}
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_MessageSendEventZ_new(uint32_tArray elems) {
- LDKCVec_MessageSendEventZ *ret = MALLOC(sizeof(LDKCVec_MessageSendEventZ), "LDKCVec_MessageSendEventZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKMessageSendEvent) * ret->datalen, "LDKCVec_MessageSendEventZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKMessageSendEvent arr_elem_conv = *(LDKMessageSendEvent*)(arr_elem_ptr);
- arr_elem_conv = MessageSendEvent_clone((LDKMessageSendEvent*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_MessageSendEventZ CVec_MessageSendEventZ_clone(const LDKCVec_MessageSendEventZ *orig) {
LDKCVec_MessageSendEventZ ret = { .data = MALLOC(sizeof(LDKMessageSendEvent) * orig->datalen, "LDKCVec_MessageSendEventZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_InitFeaturesDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_InitFeaturesDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InitFeaturesDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_InitFeaturesDecodeErrorZ *val = (LDKCResult_InitFeaturesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NodeFeaturesDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NodeFeaturesDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NodeFeaturesDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_NodeFeaturesDecodeErrorZ *val = (LDKCResult_NodeFeaturesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelFeaturesDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ChannelFeaturesDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelFeaturesDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ChannelFeaturesDecodeErrorZ *val = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_InvoiceFeaturesDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_InvoiceFeaturesDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InvoiceFeaturesDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_InvoiceFeaturesDecodeErrorZ *val = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ScoringParametersDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ScoringParametersDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ScoringParametersDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ScoringParametersDecodeErrorZ *val = (LDKCResult_ScoringParametersDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ScorerDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ScorerDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ScorerDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ScorerDecodeErrorZ *val = (LDKCResult_ScorerDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *val = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *val = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_SpendableOutputDescriptorDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_SpendableOutputDescriptorDecodeErrorZ *val = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NoneNoneZ*)arg)->result_ok;
-}
void __attribute__((visibility("default"))) TS_LDKCResult_NoneNoneZ_get_ok(uint32_t arg) {
LDKCResult_NoneNoneZ *val = (LDKCResult_NoneNoneZ*)(arg & ~1);
CHECK(val->result_ok);
return ret_arr;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(uint32_t arg) {
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *val = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(arg & ~1);
CHECK(val->result_ok);
CHECK(!val->result_ok);
return *val->contents.err;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_SignatureNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_SignatureNoneZ*)arg)->result_ok;
-}
int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_SignatureNoneZ_get_ok(uint32_t arg) {
LDKCResult_SignatureNoneZ *val = (LDKCResult_SignatureNoneZ*)(arg & ~1);
CHECK(val->result_ok);
holder_tx_var = HolderCommitmentTransaction_clone(holder_tx);
CHECK((((uint64_t)holder_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&holder_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_tx_var);
holder_tx_ref = (uint64_t)holder_tx_var.inner;
if (holder_tx_var.is_owned) {
holder_tx_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
- ret_conv = CResult_NoneNoneZ_clone((LDKCResult_NoneNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKThirtyTwoBytes channel_keys_id_LDKBaseSign_jcall(const void* this_arg) {
commitment_tx_var = CommitmentTransaction_clone(commitment_tx);
CHECK((((uint64_t)commitment_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&commitment_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_var);
commitment_tx_ref = (uint64_t)commitment_tx_var.inner;
if (commitment_tx_var.is_owned) {
commitment_tx_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(ret_ptr);
- ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_NoneNoneZ validate_counterparty_revocation_LDKBaseSign_jcall(const void* this_arg, uint64_t idx, const uint8_t (* secret)[32]) {
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
- ret_conv = CResult_NoneNoneZ_clone((LDKCResult_NoneNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_holder_commitment_and_htlcs_LDKBaseSign_jcall(const void* this_arg, const LDKHolderCommitmentTransaction * commitment_tx) {
commitment_tx_var = HolderCommitmentTransaction_clone(commitment_tx);
CHECK((((uint64_t)commitment_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&commitment_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_var);
commitment_tx_ref = (uint64_t)commitment_tx_var.inner;
if (commitment_tx_var.is_owned) {
commitment_tx_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(ret_ptr);
- ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_SignatureNoneZ sign_justice_revoked_output_LDKBaseSign_jcall(const void* this_arg, LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (* per_commitment_key)[32]) {
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_SignatureNoneZ sign_justice_revoked_htlc_LDKBaseSign_jcall(const void* this_arg, LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (* per_commitment_key)[32], const LDKHTLCOutputInCommitment * htlc) {
htlc_var = HTLCOutputInCommitment_clone(htlc);
CHECK((((uint64_t)htlc_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&htlc_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_var);
htlc_ref = (uint64_t)htlc_var.inner;
if (htlc_var.is_owned) {
htlc_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_SignatureNoneZ sign_counterparty_htlc_transaction_LDKBaseSign_jcall(const void* this_arg, LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, LDKPublicKey per_commitment_point, const LDKHTLCOutputInCommitment * htlc) {
htlc_var = HTLCOutputInCommitment_clone(htlc);
CHECK((((uint64_t)htlc_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&htlc_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_var);
htlc_ref = (uint64_t)htlc_var.inner;
if (htlc_var.is_owned) {
htlc_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_SignatureNoneZ sign_closing_transaction_LDKBaseSign_jcall(const void* this_arg, const LDKClosingTransaction * closing_tx) {
closing_tx_var = ClosingTransaction_clone(closing_tx);
CHECK((((uint64_t)closing_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&closing_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(closing_tx_var);
closing_tx_ref = (uint64_t)closing_tx_var.inner;
if (closing_tx_var.is_owned) {
closing_tx_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_SignatureNoneZ sign_channel_announcement_LDKBaseSign_jcall(const void* this_arg, const LDKUnsignedChannelAnnouncement * msg) {
msg_var = UnsignedChannelAnnouncement_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
void ready_channel_LDKBaseSign_jcall(void* this_arg, const LDKChannelTransactionParameters * channel_parameters) {
channel_parameters_var = ChannelTransactionParameters_clone(channel_parameters);
CHECK((((uint64_t)channel_parameters_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&channel_parameters_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_var);
channel_parameters_ref = (uint64_t)channel_parameters_var.inner;
if (channel_parameters_var.is_owned) {
channel_parameters_ref |= 1;
LDKChannelPublicKeys pubkeys_conv;
pubkeys_conv.inner = (void*)(pubkeys & (~1));
pubkeys_conv.is_owned = (pubkeys & 1) || (pubkeys == 0);
- pubkeys_conv = ChannelPublicKeys_clone(&pubkeys_conv);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_conv);
LDKBaseSign ret = {
.this_arg = (void*) calls,
LDKHolderCommitmentTransaction holder_tx_conv;
holder_tx_conv.inner = (void*)(holder_tx & (~1));
holder_tx_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_tx_conv);
LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
*ret_conv = (this_arg_conv->validate_holder_commitment)(this_arg_conv->this_arg, &holder_tx_conv);
return (uint64_t)ret_conv;
LDKCommitmentTransaction commitment_tx_conv;
commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
commitment_tx_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
*ret_conv = (this_arg_conv->sign_counterparty_commitment)(this_arg_conv->this_arg, &commitment_tx_conv);
return (uint64_t)ret_conv;
LDKHolderCommitmentTransaction commitment_tx_conv;
commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
commitment_tx_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
*ret_conv = (this_arg_conv->sign_holder_commitment_and_htlcs)(this_arg_conv->this_arg, &commitment_tx_conv);
return (uint64_t)ret_conv;
LDKHTLCOutputInCommitment htlc_conv;
htlc_conv.inner = (void*)(htlc & (~1));
htlc_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
*ret_conv = (this_arg_conv->sign_justice_revoked_htlc)(this_arg_conv->this_arg, justice_tx_ref, input, amount, per_commitment_key_ref, &htlc_conv);
return (uint64_t)ret_conv;
LDKHTLCOutputInCommitment htlc_conv;
htlc_conv.inner = (void*)(htlc & (~1));
htlc_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
*ret_conv = (this_arg_conv->sign_counterparty_htlc_transaction)(this_arg_conv->this_arg, htlc_tx_ref, input, amount, per_commitment_point_ref, &htlc_conv);
return (uint64_t)ret_conv;
LDKClosingTransaction closing_tx_conv;
closing_tx_conv.inner = (void*)(closing_tx & (~1));
closing_tx_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(closing_tx_conv);
LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
*ret_conv = (this_arg_conv->sign_closing_transaction)(this_arg_conv->this_arg, &closing_tx_conv);
return (uint64_t)ret_conv;
LDKUnsignedChannelAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
*ret_conv = (this_arg_conv->sign_channel_announcement)(this_arg_conv->this_arg, &msg_conv);
return (uint64_t)ret_conv;
LDKChannelTransactionParameters channel_parameters_conv;
channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
channel_parameters_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
(this_arg_conv->ready_channel)(this_arg_conv->this_arg, &channel_parameters_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelPublicKeys pubkeys_conv;
pubkeys_conv.inner = (void*)(pubkeys & (~1));
pubkeys_conv.is_owned = (pubkeys & 1) || (pubkeys == 0);
- pubkeys_conv = ChannelPublicKeys_clone(&pubkeys_conv);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_conv);
LDKSign ret = {
.this_arg = (void*) calls,
return ret_arr;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_SignDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_SignDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_SignDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_SignDecodeErrorZ *val = (LDKCResult_SignDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_RecoverableSignatureNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_RecoverableSignatureNoneZ*)arg)->result_ok;
-}
int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_RecoverableSignatureNoneZ_get_ok(uint32_t arg) {
LDKCResult_RecoverableSignatureNoneZ *val = (LDKCResult_RecoverableSignatureNoneZ*)(arg & ~1);
CHECK(val->result_ok);
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_CVec_CVec_u8ZZNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_CVec_CVec_u8ZZNoneZ*)arg)->result_ok;
-}
ptrArray __attribute__((visibility("default"))) TS_LDKCResult_CVec_CVec_u8ZZNoneZ_get_ok(uint32_t arg) {
LDKCResult_CVec_CVec_u8ZZNoneZ *val = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(arg & ~1);
CHECK(val->result_ok);
CHECK(!val->result_ok);
return *val->contents.err;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_InMemorySignerDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_InMemorySignerDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InMemorySignerDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_InMemorySignerDecodeErrorZ *val = (LDKCResult_InMemorySignerDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_TxOutZ_new(uint32_tArray elems) {
- LDKCVec_TxOutZ *ret = MALLOC(sizeof(LDKCVec_TxOutZ), "LDKCVec_TxOutZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKTxOut) * ret->datalen, "LDKCVec_TxOutZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKTxOut arr_elem_conv = *(LDKTxOut*)(arr_elem_ptr);
- arr_elem_conv = TxOut_clone((LDKTxOut*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_TxOutZ CVec_TxOutZ_clone(const LDKCVec_TxOutZ *orig) {
LDKCVec_TxOutZ ret = { .data = MALLOC(sizeof(LDKTxOut) * orig->datalen, "LDKCVec_TxOutZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_TransactionNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_TransactionNoneZ*)arg)->result_ok;
-}
int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_TransactionNoneZ_get_ok(uint32_t arg) {
LDKCResult_TransactionNoneZ *val = (LDKCResult_TransactionNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_BlockHashChannelMonitorZZ_new(uint32_tArray elems) {
- LDKCVec_C2Tuple_BlockHashChannelMonitorZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ), "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ) * ret->datalen, "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_BlockHashChannelMonitorZ arr_elem_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_BlockHashChannelMonitorZ_clone((LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_BlockHashChannelMonitorZZ CVec_C2Tuple_BlockHashChannelMonitorZZ_clone(const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ *orig) {
LDKCVec_C2Tuple_BlockHashChannelMonitorZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ) * orig->datalen, "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)arg)->result_ok;
-}
uint32_tArray __attribute__((visibility("default"))) TS_LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_get_ok(uint32_t arg) {
LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ *val = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t script_ref = 0;
CHECK((((uint64_t)script_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&script_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(script_var);
script_ref = (uint64_t)script_var.inner & ~1;
return 0 /* LDKAPIError - IncompatibleShutdownScript */; (void) script_ref;
}
default: abort();
}
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneAPIErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NoneAPIErrorZ*)arg)->result_ok;
-}
void __attribute__((visibility("default"))) TS_LDKCResult_NoneAPIErrorZ_get_ok(uint32_t arg) {
LDKCResult_NoneAPIErrorZ *val = (LDKCResult_NoneAPIErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
return err_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_CResult_NoneAPIErrorZZ_new(uint32_tArray elems) {
- LDKCVec_CResult_NoneAPIErrorZZ *ret = MALLOC(sizeof(LDKCVec_CResult_NoneAPIErrorZZ), "LDKCVec_CResult_NoneAPIErrorZZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ) * ret->datalen, "LDKCVec_CResult_NoneAPIErrorZZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKCResult_NoneAPIErrorZ arr_elem_conv = *(LDKCResult_NoneAPIErrorZ*)(arr_elem_ptr);
- arr_elem_conv = CResult_NoneAPIErrorZ_clone((LDKCResult_NoneAPIErrorZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_CResult_NoneAPIErrorZZ CVec_CResult_NoneAPIErrorZZ_clone(const LDKCVec_CResult_NoneAPIErrorZZ *orig) {
LDKCVec_CResult_NoneAPIErrorZZ ret = { .data = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ) * orig->datalen, "LDKCVec_CResult_NoneAPIErrorZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_APIErrorZ_new(uint32_tArray elems) {
- LDKCVec_APIErrorZ *ret = MALLOC(sizeof(LDKCVec_APIErrorZ), "LDKCVec_APIErrorZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKAPIError) * ret->datalen, "LDKCVec_APIErrorZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKAPIError arr_elem_conv = *(LDKAPIError*)(arr_elem_ptr);
- arr_elem_conv = APIError_clone((LDKAPIError*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_APIErrorZ CVec_APIErrorZ_clone(const LDKCVec_APIErrorZ *orig) {
LDKCVec_APIErrorZ ret = { .data = MALLOC(sizeof(LDKAPIError) * orig->datalen, "LDKCVec_APIErrorZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult__u832APIErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult__u832APIErrorZ*)arg)->result_ok;
-}
int8_tArray __attribute__((visibility("default"))) TS_LDKCResult__u832APIErrorZ_get_ok(uint32_t arg) {
LDKCResult__u832APIErrorZ *val = (LDKCResult__u832APIErrorZ*)(arg & ~1);
CHECK(val->result_ok);
if ((uint64_t)failed_paths_retry_var.inner > 4096) {
CHECK((((uint64_t)failed_paths_retry_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&failed_paths_retry_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(failed_paths_retry_var);
failed_paths_retry_ref = (uint64_t)failed_paths_retry_var.inner & ~1;
}
int8_tArray payment_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
default: abort();
}
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_PaymentIdPaymentSendFailureZ_result_ok(uint32_t arg) {
- return ((LDKCResult_PaymentIdPaymentSendFailureZ*)arg)->result_ok;
-}
int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_PaymentIdPaymentSendFailureZ_get_ok(uint32_t arg) {
LDKCResult_PaymentIdPaymentSendFailureZ *val = (LDKCResult_PaymentIdPaymentSendFailureZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NonePaymentSendFailureZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NonePaymentSendFailureZ*)arg)->result_ok;
-}
void __attribute__((visibility("default"))) TS_LDKCResult_NonePaymentSendFailureZ_get_ok(uint32_t arg) {
LDKCResult_NonePaymentSendFailureZ *val = (LDKCResult_NonePaymentSendFailureZ*)(arg & ~1);
CHECK(val->result_ok);
return ret_arr;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_result_ok(uint32_t arg) {
- return ((LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(uint32_t arg) {
LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *val = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(arg & ~1);
CHECK(val->result_ok);
default: abort();
}
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_NetAddressZ_new(uint32_tArray elems) {
- LDKCVec_NetAddressZ *ret = MALLOC(sizeof(LDKCVec_NetAddressZ), "LDKCVec_NetAddressZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKNetAddress) * ret->datalen, "LDKCVec_NetAddressZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKNetAddress arr_elem_conv = *(LDKNetAddress*)(arr_elem_ptr);
- arr_elem_conv = NetAddress_clone((LDKNetAddress*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_NetAddressZ CVec_NetAddressZ_clone(const LDKCVec_NetAddressZ *orig) {
LDKCVec_NetAddressZ ret = { .data = MALLOC(sizeof(LDKNetAddress) * orig->datalen, "LDKCVec_NetAddressZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
return ret_arr;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_PaymentSecretAPIErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_PaymentSecretAPIErrorZ*)arg)->result_ok;
-}
int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_PaymentSecretAPIErrorZ_get_ok(uint32_t arg) {
LDKCResult_PaymentSecretAPIErrorZ *val = (LDKCResult_PaymentSecretAPIErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
return err_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_ChannelMonitorZ_new(uint32_tArray elems) {
- LDKCVec_ChannelMonitorZ *ret = MALLOC(sizeof(LDKCVec_ChannelMonitorZ), "LDKCVec_ChannelMonitorZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKChannelMonitor) * ret->datalen, "LDKCVec_ChannelMonitorZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKChannelMonitor arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = ChannelMonitor_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_ChannelMonitorZ CVec_ChannelMonitorZ_clone(const LDKCVec_ChannelMonitorZ *orig) {
LDKCVec_ChannelMonitorZ ret = { .data = MALLOC(sizeof(LDKChannelMonitor) * orig->datalen, "LDKCVec_ChannelMonitorZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
uint64_t funding_txo_ref = 0;
CHECK((((uint64_t)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
funding_txo_ref = (uint64_t)funding_txo_var.inner;
if (funding_txo_var.is_owned) {
funding_txo_ref |= 1;
uint64_t monitor_ref = 0;
CHECK((((uint64_t)monitor_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&monitor_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(monitor_var);
monitor_ref = (uint64_t)monitor_var.inner;
if (monitor_var.is_owned) {
monitor_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(ret_ptr);
- ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_NoneChannelMonitorUpdateErrZ update_channel_LDKWatch_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitorUpdate update) {
uint64_t funding_txo_ref = 0;
CHECK((((uint64_t)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
funding_txo_ref = (uint64_t)funding_txo_var.inner;
if (funding_txo_var.is_owned) {
funding_txo_ref |= 1;
uint64_t update_ref = 0;
CHECK((((uint64_t)update_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_var);
update_ref = (uint64_t)update_var.inner;
if (update_var.is_owned) {
update_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(ret_ptr);
- ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCVec_MonitorEventZ release_pending_monitor_events_LDKWatch_jcall(const void* this_arg) {
void* ret_conv_14_ptr = (void*)(((uint64_t)ret_conv_14) & ~1);
CHECK_ACCESS(ret_conv_14_ptr);
LDKMonitorEvent ret_conv_14_conv = *(LDKMonitorEvent*)(ret_conv_14_ptr);
- ret_conv_14_conv = MonitorEvent_clone((LDKMonitorEvent*)(((uint64_t)ret_conv_14) & ~1));
+ FREE((void*)ret_conv_14);
ret_constr.data[o] = ret_conv_14_conv;
}
return ret_constr;
LDKOutPoint funding_txo_conv;
funding_txo_conv.inner = (void*)(funding_txo & (~1));
funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
funding_txo_conv = OutPoint_clone(&funding_txo_conv);
LDKChannelMonitor monitor_conv;
monitor_conv.inner = (void*)(monitor & (~1));
monitor_conv.is_owned = (monitor & 1) || (monitor == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(monitor_conv);
monitor_conv = ChannelMonitor_clone(&monitor_conv);
LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
*ret_conv = (this_arg_conv->watch_channel)(this_arg_conv->this_arg, funding_txo_conv, monitor_conv);
LDKOutPoint funding_txo_conv;
funding_txo_conv.inner = (void*)(funding_txo & (~1));
funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
funding_txo_conv = OutPoint_clone(&funding_txo_conv);
LDKChannelMonitorUpdate update_conv;
update_conv.inner = (void*)(update & (~1));
update_conv.is_owned = (update & 1) || (update == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_conv);
update_conv = ChannelMonitorUpdate_clone(&update_conv);
LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
*ret_conv = (this_arg_conv->update_channel)(this_arg_conv->this_arg, funding_txo_conv, update_conv);
LDKShutdownScript ret_conv;
ret_conv.inner = (void*)(ret & (~1));
ret_conv.is_owned = (ret & 1) || (ret == 0);
- ret_conv = ShutdownScript_clone(&ret_conv);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
return ret_conv;
}
LDKSign get_channel_signer_LDKKeysInterface_jcall(const void* this_arg, bool inbound, uint64_t channel_value_satoshis) {
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKSign ret_conv = *(LDKSign*)(ret_ptr);
- ret_conv = Sign_clone(&ret_conv);
+ FREE((void*)ret);
return ret_conv;
}
LDKThirtyTwoBytes get_secure_random_bytes_LDKKeysInterface_jcall(const void* this_arg) {
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_SignDecodeErrorZ ret_conv = *(LDKCResult_SignDecodeErrorZ*)(ret_ptr);
- ret_conv = CResult_SignDecodeErrorZ_clone((LDKCResult_SignDecodeErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_RecoverableSignatureNoneZ sign_invoice_LDKKeysInterface_jcall(const void* this_arg, LDKCVec_u8Z invoice_preimage) {
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_RecoverableSignatureNoneZ ret_conv = *(LDKCResult_RecoverableSignatureNoneZ*)(ret_ptr);
- ret_conv = CResult_RecoverableSignatureNoneZ_clone((LDKCResult_RecoverableSignatureNoneZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
static void LDKKeysInterface_JCalls_cloned(LDKKeysInterface* new_obj) {
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
FREE(j_calls);
}
}
-void log_LDKLogger_jcall(const void* this_arg, const char* record) {
+void log_LDKLogger_jcall(const void* this_arg, const LDKRecord * record) {
LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
- const char* record_str = record;
- jstring record_conv = str_ref_to_ts(record_str, strlen(record_str));
- js_invoke_function_1(j_calls->log_meth, record_conv);
+ LDKRecord record_var = *record;
+ uint64_t record_ref = 0;
+ record_var = Record_clone(record);
+ CHECK((((uint64_t)record_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&record_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(record_var);
+ record_ref = (uint64_t)record_var.inner;
+ if (record_var.is_owned) {
+ record_ref |= 1;
+ }
+ js_invoke_function_1(j_calls->log_meth, record_ref);
}
static void LDKLogger_JCalls_cloned(LDKLogger* new_obj) {
LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) new_obj->this_arg;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner & ~1;
return ret_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelConfigDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ChannelConfigDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelConfigDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ChannelConfigDecodeErrorZ *val = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_OutPointDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_OutPointDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_OutPointDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_OutPointDecodeErrorZ *val = (LDKCResult_OutPointDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
default: abort();
}
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_COption_TypeZDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_COption_TypeZDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_COption_TypeZDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_COption_TypeZDecodeErrorZ *val = (LDKCResult_COption_TypeZDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
uint64_t routing_ref = 0;
CHECK((((uint64_t)routing_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&routing_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(routing_var);
routing_ref = (uint64_t)routing_var.inner & ~1;
return 0 /* LDKPaymentError - Routing */; (void) routing_ref;
}
default: abort();
}
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_PaymentIdPaymentErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_PaymentIdPaymentErrorZ*)arg)->result_ok;
-}
int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_PaymentIdPaymentErrorZ_get_ok(uint32_t arg) {
LDKCResult_PaymentIdPaymentErrorZ *val = (LDKCResult_PaymentIdPaymentErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_SiPrefixNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_SiPrefixNoneZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_SiPrefixNoneZ_get_ok(uint32_t arg) {
LDKCResult_SiPrefixNoneZ *val = (LDKCResult_SiPrefixNoneZ*)(arg & ~1);
CHECK(val->result_ok);
CHECK(!val->result_ok);
return *val->contents.err;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_InvoiceNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_InvoiceNoneZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InvoiceNoneZ_get_ok(uint32_t arg) {
LDKCResult_InvoiceNoneZ *val = (LDKCResult_InvoiceNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
CHECK(!val->result_ok);
return *val->contents.err;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_SignedRawInvoiceNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_SignedRawInvoiceNoneZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_SignedRawInvoiceNoneZ_get_ok(uint32_t arg) {
LDKCResult_SignedRawInvoiceNoneZ *val = (LDKCResult_SignedRawInvoiceNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_PayeePubKeyErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_PayeePubKeyErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PayeePubKeyErrorZ_get_ok(uint32_t arg) {
LDKCResult_PayeePubKeyErrorZ *val = (LDKCResult_PayeePubKeyErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint32_t err_conv = LDKSecp256k1Error_to_js((*val->contents.err));
return err_conv;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_PrivateRouteZ_new(uint32_tArray elems) {
- LDKCVec_PrivateRouteZ *ret = MALLOC(sizeof(LDKCVec_PrivateRouteZ), "LDKCVec_PrivateRouteZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKPrivateRoute) * ret->datalen, "LDKCVec_PrivateRouteZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKPrivateRoute arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = PrivateRoute_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_PrivateRouteZ CVec_PrivateRouteZ_clone(const LDKCVec_PrivateRouteZ *orig) {
LDKCVec_PrivateRouteZ ret = { .data = MALLOC(sizeof(LDKPrivateRoute) * orig->datalen, "LDKCVec_PrivateRouteZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_PositiveTimestampCreationErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_PositiveTimestampCreationErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PositiveTimestampCreationErrorZ_get_ok(uint32_t arg) {
LDKCResult_PositiveTimestampCreationErrorZ *val = (LDKCResult_PositiveTimestampCreationErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint32_t err_conv = LDKCreationError_to_js((*val->contents.err));
return err_conv;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneSemanticErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NoneSemanticErrorZ*)arg)->result_ok;
-}
void __attribute__((visibility("default"))) TS_LDKCResult_NoneSemanticErrorZ_get_ok(uint32_t arg) {
LDKCResult_NoneSemanticErrorZ *val = (LDKCResult_NoneSemanticErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint32_t err_conv = LDKSemanticError_to_js((*val->contents.err));
return err_conv;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_InvoiceSemanticErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_InvoiceSemanticErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InvoiceSemanticErrorZ_get_ok(uint32_t arg) {
LDKCResult_InvoiceSemanticErrorZ *val = (LDKCResult_InvoiceSemanticErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint32_t err_conv = LDKSemanticError_to_js((*val->contents.err));
return err_conv;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_DescriptionCreationErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_DescriptionCreationErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_DescriptionCreationErrorZ_get_ok(uint32_t arg) {
LDKCResult_DescriptionCreationErrorZ *val = (LDKCResult_DescriptionCreationErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint32_t err_conv = LDKCreationError_to_js((*val->contents.err));
return err_conv;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ExpiryTimeCreationErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ExpiryTimeCreationErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ExpiryTimeCreationErrorZ_get_ok(uint32_t arg) {
LDKCResult_ExpiryTimeCreationErrorZ *val = (LDKCResult_ExpiryTimeCreationErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint32_t err_conv = LDKCreationError_to_js((*val->contents.err));
return err_conv;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_PrivateRouteCreationErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_PrivateRouteCreationErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PrivateRouteCreationErrorZ_get_ok(uint32_t arg) {
LDKCResult_PrivateRouteCreationErrorZ *val = (LDKCResult_PrivateRouteCreationErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint32_t err_conv = LDKCreationError_to_js((*val->contents.err));
return err_conv;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_StringErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_StringErrorZ*)arg)->result_ok;
-}
jstring __attribute__((visibility("default"))) TS_LDKCResult_StringErrorZ_get_ok(uint32_t arg) {
LDKCResult_StringErrorZ *val = (LDKCResult_StringErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint32_t err_conv = LDKSecp256k1Error_to_js((*val->contents.err));
return err_conv;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelMonitorUpdateDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ChannelMonitorUpdateDecodeErrorZ *val = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_HTLCUpdateDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_HTLCUpdateDecodeErrorZ*)arg)->result_ok;
+uint32_t __attribute__((visibility("default"))) TS_LDKCOption_MonitorEventZ_ref_from_ptr(uint32_t ptr) {
+ LDKCOption_MonitorEventZ *obj = (LDKCOption_MonitorEventZ*)(ptr & ~1);
+ switch(obj->tag) {
+ case LDKCOption_MonitorEventZ_Some: {
+ uint64_t some_ref = ((uint64_t)&obj->some) | 1;
+ return 0 /* LDKCOption_MonitorEventZ - Some */; (void) some_ref;
+ }
+ case LDKCOption_MonitorEventZ_None: {
+ return 0 /* LDKCOption_MonitorEventZ - None */;
+ }
+ default: abort();
+ }
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCResult_COption_MonitorEventZDecodeErrorZ_get_ok(uint32_t arg) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ *val = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(arg & ~1);
+ CHECK(val->result_ok);
+ uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
+ return res_ref;
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCResult_COption_MonitorEventZDecodeErrorZ_get_err(uint32_t arg) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ *val = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(arg & ~1);
+ CHECK(!val->result_ok);
+ LDKDecodeError err_var = (*val->contents.err);
+ uint64_t err_ref = 0;
+ CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
+ err_ref = (uint64_t)err_var.inner & ~1;
+ return err_ref;
}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_HTLCUpdateDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_HTLCUpdateDecodeErrorZ *val = (LDKCResult_HTLCUpdateDecodeErrorZ*)(arg & ~1);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneMonitorUpdateErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NoneMonitorUpdateErrorZ*)arg)->result_ok;
-}
void __attribute__((visibility("default"))) TS_LDKCResult_NoneMonitorUpdateErrorZ_get_ok(uint32_t arg) {
LDKCResult_NoneMonitorUpdateErrorZ *val = (LDKCResult_NoneMonitorUpdateErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_arr;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_u32ScriptZZ_new(uint32_tArray elems) {
- LDKCVec_C2Tuple_u32ScriptZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_u32ScriptZZ), "LDKCVec_C2Tuple_u32ScriptZZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ) * ret->datalen, "LDKCVec_C2Tuple_u32ScriptZZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_u32ScriptZ arr_elem_conv = *(LDKC2Tuple_u32ScriptZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_u32ScriptZ_clone((LDKC2Tuple_u32ScriptZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_u32ScriptZZ CVec_C2Tuple_u32ScriptZZ_clone(const LDKCVec_C2Tuple_u32ScriptZZ *orig) {
LDKCVec_C2Tuple_u32ScriptZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ) * orig->datalen, "LDKCVec_C2Tuple_u32ScriptZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
return ret_arr;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_new(uint32_tArray elems) {
- LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ) * ret->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ arr_elem_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone((LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_clone(const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ *orig) {
LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ) * orig->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKPaymentPurpose_ref_from_ptr(uint32_t ptr) {
- LDKPaymentPurpose *obj = (LDKPaymentPurpose*)(ptr & ~1);
- switch(obj->tag) {
- case LDKPaymentPurpose_InvoicePayment: {
- int8_tArray payment_preimage_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(payment_preimage_arr + 4), obj->invoice_payment.payment_preimage.data, 32);
- int8_tArray payment_secret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(payment_secret_arr + 4), obj->invoice_payment.payment_secret.data, 32);
- return 0 /* LDKPaymentPurpose - InvoicePayment */; (void) payment_preimage_arr; (void) payment_secret_arr; (void) obj->invoice_payment.user_payment_id;
- }
- case LDKPaymentPurpose_SpontaneousPayment: {
- int8_tArray spontaneous_payment_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(spontaneous_payment_arr + 4), obj->spontaneous_payment.data, 32);
- return 0 /* LDKPaymentPurpose - SpontaneousPayment */; (void) spontaneous_payment_arr;
- }
- default: abort();
- }
-}
-uint32_t __attribute__((visibility("default"))) TS_LDKClosureReason_ref_from_ptr(uint32_t ptr) {
- LDKClosureReason *obj = (LDKClosureReason*)(ptr & ~1);
- switch(obj->tag) {
- case LDKClosureReason_CounterpartyForceClosed: {
- LDKStr peer_msg_str = obj->counterparty_force_closed.peer_msg;
- jstring peer_msg_conv = str_ref_to_ts(peer_msg_str.chars, peer_msg_str.len);
- return 0 /* LDKClosureReason - CounterpartyForceClosed */; (void) peer_msg_conv;
- }
- case LDKClosureReason_HolderForceClosed: {
- return 0 /* LDKClosureReason - HolderForceClosed */;
- }
- case LDKClosureReason_CooperativeClosure: {
- return 0 /* LDKClosureReason - CooperativeClosure */;
- }
- case LDKClosureReason_CommitmentTxConfirmed: {
- return 0 /* LDKClosureReason - CommitmentTxConfirmed */;
- }
- case LDKClosureReason_ProcessingError: {
- LDKStr err_str = obj->processing_error.err;
- jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
- return 0 /* LDKClosureReason - ProcessingError */; (void) err_conv;
- }
- case LDKClosureReason_DisconnectedPeer: {
- return 0 /* LDKClosureReason - DisconnectedPeer */;
- }
- case LDKClosureReason_OutdatedChannelManager: {
- return 0 /* LDKClosureReason - OutdatedChannelManager */;
- }
- default: abort();
- }
-}
-uint32_t __attribute__((visibility("default"))) TS_LDKEvent_ref_from_ptr(uint32_t ptr) {
- LDKEvent *obj = (LDKEvent*)(ptr & ~1);
- switch(obj->tag) {
- case LDKEvent_FundingGenerationReady: {
- int8_tArray temporary_channel_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(temporary_channel_id_arr + 4), obj->funding_generation_ready.temporary_channel_id.data, 32);
- LDKCVec_u8Z output_script_var = obj->funding_generation_ready.output_script;
- int8_tArray output_script_arr = init_arr(output_script_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(output_script_arr + 4), output_script_var.data, output_script_var.datalen);
- return 0 /* LDKEvent - FundingGenerationReady */; (void) temporary_channel_id_arr; (void) obj->funding_generation_ready.channel_value_satoshis; (void) output_script_arr; (void) obj->funding_generation_ready.user_channel_id;
- }
- case LDKEvent_PaymentReceived: {
- int8_tArray payment_hash_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(payment_hash_arr + 4), obj->payment_received.payment_hash.data, 32);
- uint64_t purpose_ref = ((uint64_t)&obj->payment_received.purpose) | 1;
- return 0 /* LDKEvent - PaymentReceived */; (void) payment_hash_arr; (void) obj->payment_received.amt; (void) purpose_ref;
- }
- case LDKEvent_PaymentSent: {
- int8_tArray payment_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(payment_id_arr + 4), obj->payment_sent.payment_id.data, 32);
- int8_tArray payment_preimage_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(payment_preimage_arr + 4), obj->payment_sent.payment_preimage.data, 32);
- int8_tArray payment_hash_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(payment_hash_arr + 4), obj->payment_sent.payment_hash.data, 32);
- uint64_t fee_paid_msat_ref = ((uint64_t)&obj->payment_sent.fee_paid_msat) | 1;
- return 0 /* LDKEvent - PaymentSent */; (void) payment_id_arr; (void) payment_preimage_arr; (void) payment_hash_arr; (void) fee_paid_msat_ref;
- }
- case LDKEvent_PaymentPathFailed: {
- int8_tArray payment_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(payment_id_arr + 4), obj->payment_path_failed.payment_id.data, 32);
- int8_tArray payment_hash_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(payment_hash_arr + 4), obj->payment_path_failed.payment_hash.data, 32);
- uint64_t network_update_ref = ((uint64_t)&obj->payment_path_failed.network_update) | 1;
- LDKCVec_RouteHopZ path_var = obj->payment_path_failed.path;
- uint32_tArray path_arr = NULL;
- path_arr = init_arr(path_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
- uint32_t *path_arr_ptr = (uint32_t*)(path_arr + 4);
- for (size_t k = 0; k < path_var.datalen; k++) {
- LDKRouteHop path_conv_10_var = path_var.data[k];
- uint64_t path_conv_10_ref = 0;
- CHECK((((uint64_t)path_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
- CHECK((((uint64_t)&path_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
- path_conv_10_ref = (uint64_t)path_conv_10_var.inner & ~1;
- path_arr_ptr[k] = path_conv_10_ref;
- }
-
- uint64_t short_channel_id_ref = ((uint64_t)&obj->payment_path_failed.short_channel_id) | 1;
- LDKRouteParameters retry_var = obj->payment_path_failed.retry;
- uint64_t retry_ref = 0;
- if ((uint64_t)retry_var.inner > 4096) {
- CHECK((((uint64_t)retry_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
- CHECK((((uint64_t)&retry_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
- retry_ref = (uint64_t)retry_var.inner & ~1;
- }
- return 0 /* LDKEvent - PaymentPathFailed */; (void) payment_id_arr; (void) payment_hash_arr; (void) obj->payment_path_failed.rejected_by_dest; (void) network_update_ref; (void) obj->payment_path_failed.all_paths_failed; (void) path_arr; (void) short_channel_id_ref; (void) retry_ref;
- }
- case LDKEvent_PendingHTLCsForwardable: {
- return 0 /* LDKEvent - PendingHTLCsForwardable */; (void) obj->pending_htl_cs_forwardable.time_forwardable;
- }
- case LDKEvent_SpendableOutputs: {
- LDKCVec_SpendableOutputDescriptorZ outputs_var = obj->spendable_outputs.outputs;
- uint32_tArray outputs_arr = NULL;
- outputs_arr = init_arr(outputs_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
- uint32_t *outputs_arr_ptr = (uint32_t*)(outputs_arr + 4);
- for (size_t b = 0; b < outputs_var.datalen; b++) {
- uint64_t outputs_conv_27_ref = ((uint64_t)&outputs_var.data[b]) | 1;
- outputs_arr_ptr[b] = outputs_conv_27_ref;
- }
-
- return 0 /* LDKEvent - SpendableOutputs */; (void) outputs_arr;
- }
- case LDKEvent_PaymentForwarded: {
- uint64_t fee_earned_msat_ref = ((uint64_t)&obj->payment_forwarded.fee_earned_msat) | 1;
- return 0 /* LDKEvent - PaymentForwarded */; (void) fee_earned_msat_ref; (void) obj->payment_forwarded.claim_from_onchain_tx;
- }
- case LDKEvent_ChannelClosed: {
- int8_tArray channel_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(channel_id_arr + 4), obj->channel_closed.channel_id.data, 32);
- uint64_t reason_ref = ((uint64_t)&obj->channel_closed.reason) | 1;
- return 0 /* LDKEvent - ChannelClosed */; (void) channel_id_arr; (void) obj->channel_closed.user_channel_id; (void) reason_ref;
- }
- case LDKEvent_DiscardFunding: {
- int8_tArray channel_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(channel_id_arr + 4), obj->discard_funding.channel_id.data, 32);
- LDKTransaction transaction_var = obj->discard_funding.transaction;
- int8_tArray transaction_arr = init_arr(transaction_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
- memcpy((uint8_t*)(transaction_arr + 4), transaction_var.data, transaction_var.datalen);
- return 0 /* LDKEvent - DiscardFunding */; (void) channel_id_arr; (void) transaction_arr;
- }
- default: abort();
- }
-}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_EventZ_new(uint32_tArray elems) {
- LDKCVec_EventZ *ret = MALLOC(sizeof(LDKCVec_EventZ), "LDKCVec_EventZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKEvent) * ret->datalen, "LDKCVec_EventZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKEvent arr_elem_conv = *(LDKEvent*)(arr_elem_ptr);
- arr_elem_conv = Event_clone((LDKEvent*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_EventZ CVec_EventZ_clone(const LDKCVec_EventZ *orig) {
LDKCVec_EventZ ret = { .data = MALLOC(sizeof(LDKEvent) * orig->datalen, "LDKCVec_EventZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
return (uint64_t)ret_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_u32TxOutZZ_new(uint32_tArray elems) {
- LDKCVec_C2Tuple_u32TxOutZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_u32TxOutZZ), "LDKCVec_C2Tuple_u32TxOutZZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ) * ret->datalen, "LDKCVec_C2Tuple_u32TxOutZZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_u32TxOutZ arr_elem_conv = *(LDKC2Tuple_u32TxOutZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_u32TxOutZ_clone((LDKC2Tuple_u32TxOutZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_u32TxOutZZ CVec_C2Tuple_u32TxOutZZ_clone(const LDKCVec_C2Tuple_u32TxOutZZ *orig) {
LDKCVec_C2Tuple_u32TxOutZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ) * orig->datalen, "LDKCVec_C2Tuple_u32TxOutZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
return ret_arr;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_new(uint32_tArray elems) {
- LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ) * ret->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ arr_elem_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone((LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_clone(const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ *orig) {
LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ) * orig->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
default: abort();
}
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_BalanceZ_new(uint32_tArray elems) {
- LDKCVec_BalanceZ *ret = MALLOC(sizeof(LDKCVec_BalanceZ), "LDKCVec_BalanceZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKBalance) * ret->datalen, "LDKCVec_BalanceZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKBalance arr_elem_conv = *(LDKBalance*)(arr_elem_ptr);
- arr_elem_conv = Balance_clone((LDKBalance*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_BalanceZ CVec_BalanceZ_clone(const LDKCVec_BalanceZ *orig) {
LDKCVec_BalanceZ ret = { .data = MALLOC(sizeof(LDKBalance) * orig->datalen, "LDKCVec_BalanceZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneLightningErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NoneLightningErrorZ*)arg)->result_ok;
-}
void __attribute__((visibility("default"))) TS_LDKCResult_NoneLightningErrorZ_get_ok(uint32_t arg) {
LDKCResult_NoneLightningErrorZ *val = (LDKCResult_NoneLightningErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
return (uint64_t)ret_ret;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_PublicKeyTypeZZ_new(uint32_tArray elems) {
- LDKCVec_C2Tuple_PublicKeyTypeZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_PublicKeyTypeZZ), "LDKCVec_C2Tuple_PublicKeyTypeZZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ) * ret->datalen, "LDKCVec_C2Tuple_PublicKeyTypeZZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC2Tuple_PublicKeyTypeZ arr_elem_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(arr_elem_ptr);
- arr_elem_conv = C2Tuple_PublicKeyTypeZ_clone((LDKC2Tuple_PublicKeyTypeZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C2Tuple_PublicKeyTypeZZ CVec_C2Tuple_PublicKeyTypeZZ_clone(const LDKCVec_C2Tuple_PublicKeyTypeZZ *orig) {
LDKCVec_C2Tuple_PublicKeyTypeZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ) * orig->datalen, "LDKCVec_C2Tuple_PublicKeyTypeZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_boolLightningErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_boolLightningErrorZ*)arg)->result_ok;
-}
jboolean __attribute__((visibility("default"))) TS_LDKCResult_boolLightningErrorZ_get_ok(uint32_t arg) {
LDKCResult_boolLightningErrorZ *val = (LDKCResult_boolLightningErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_new(uint32_tArray elems) {
- LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret = MALLOC(sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) * ret->datalen, "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- void* arr_elem_ptr = (void*)(((uint64_t)arr_elem) & ~1);
- CHECK_ACCESS(arr_elem_ptr);
- LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ arr_elem_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(arr_elem_ptr);
- arr_elem_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone((LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)arr_elem) & ~1));
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *orig) {
LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret = { .data = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) * orig->datalen, "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_NodeAnnouncementZ_new(uint32_tArray elems) {
- LDKCVec_NodeAnnouncementZ *ret = MALLOC(sizeof(LDKCVec_NodeAnnouncementZ), "LDKCVec_NodeAnnouncementZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKNodeAnnouncement) * ret->datalen, "LDKCVec_NodeAnnouncementZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKNodeAnnouncement arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = NodeAnnouncement_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_NodeAnnouncementZ CVec_NodeAnnouncementZ_clone(const LDKCVec_NodeAnnouncementZ *orig) {
LDKCVec_NodeAnnouncementZ ret = { .data = MALLOC(sizeof(LDKNodeAnnouncement) * orig->datalen, "LDKCVec_NodeAnnouncementZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_CVec_u8ZPeerHandleErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_CVec_u8ZPeerHandleErrorZ*)arg)->result_ok;
-}
int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_CVec_u8ZPeerHandleErrorZ_get_ok(uint32_t arg) {
LDKCResult_CVec_u8ZPeerHandleErrorZ *val = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NonePeerHandleErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NonePeerHandleErrorZ*)arg)->result_ok;
-}
void __attribute__((visibility("default"))) TS_LDKCResult_NonePeerHandleErrorZ_get_ok(uint32_t arg) {
LDKCResult_NonePeerHandleErrorZ *val = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_boolPeerHandleErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_boolPeerHandleErrorZ*)arg)->result_ok;
-}
jboolean __attribute__((visibility("default"))) TS_LDKCResult_boolPeerHandleErrorZ_get_ok(uint32_t arg) {
LDKCResult_boolPeerHandleErrorZ *val = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NodeIdDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NodeIdDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NodeIdDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_NodeIdDecodeErrorZ *val = (LDKCResult_NodeIdDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
+ err_ref = (uint64_t)err_var.inner & ~1;
+ return err_ref;
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(uint32_t arg) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ *val = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(arg & ~1);
+ CHECK(val->result_ok);
+ uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
+ return res_ref;
+}
+uint32_t __attribute__((visibility("default"))) TS_LDKCResult_COption_NetworkUpdateZDecodeErrorZ_get_err(uint32_t arg) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ *val = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(arg & ~1);
+ CHECK(!val->result_ok);
+ LDKDecodeError err_var = (*val->contents.err);
+ uint64_t err_ref = 0;
+ CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_TxOutAccessErrorZ ret_conv = *(LDKCResult_TxOutAccessErrorZ*)(ret_ptr);
- ret_conv = CResult_TxOutAccessErrorZ_clone((LDKCResult_TxOutAccessErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
static void LDKAccess_JCalls_cloned(LDKAccess* new_obj) {
default: abort();
}
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_DirectionalChannelInfoDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_DirectionalChannelInfoDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_DirectionalChannelInfoDecodeErrorZ *val = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelInfoDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ChannelInfoDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelInfoDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ChannelInfoDecodeErrorZ *val = (LDKCResult_ChannelInfoDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_RoutingFeesDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_RoutingFeesDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RoutingFeesDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_RoutingFeesDecodeErrorZ *val = (LDKCResult_RoutingFeesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NodeAnnouncementInfoDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_NodeAnnouncementInfoDecodeErrorZ *val = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_u64Z_new(int64_tArray elems) {
- LDKCVec_u64Z *ret = MALLOC(sizeof(LDKCVec_u64Z), "LDKCVec_u64Z");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(uint64_t) * ret->datalen, "LDKCVec_u64Z Data");
- int64_t *java_elems = (int64_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- ret->data[i] = java_elems[i];
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_u64Z CVec_u64Z_clone(const LDKCVec_u64Z *orig) {
LDKCVec_u64Z ret = { .data = MALLOC(sizeof(int64_t) * orig->datalen, "LDKCVec_u64Z clone bytes"), .datalen = orig->datalen };
memcpy(ret.data, orig->data, sizeof(int64_t) * ret.datalen);
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NodeInfoDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NodeInfoDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NodeInfoDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_NodeInfoDecodeErrorZ *val = (LDKCResult_NodeInfoDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NetworkGraphDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NetworkGraphDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NetworkGraphDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_NetworkGraphDecodeErrorZ *val = (LDKCResult_NetworkGraphDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
default: abort();
}
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NetAddressDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NetAddressDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NetAddressDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_NetAddressDecodeErrorZ *val = (LDKCResult_NetAddressDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_UpdateAddHTLCZ_new(uint32_tArray elems) {
- LDKCVec_UpdateAddHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateAddHTLCZ), "LDKCVec_UpdateAddHTLCZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKUpdateAddHTLC) * ret->datalen, "LDKCVec_UpdateAddHTLCZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKUpdateAddHTLC arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = UpdateAddHTLC_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_UpdateAddHTLCZ CVec_UpdateAddHTLCZ_clone(const LDKCVec_UpdateAddHTLCZ *orig) {
LDKCVec_UpdateAddHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateAddHTLC) * orig->datalen, "LDKCVec_UpdateAddHTLCZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_UpdateFulfillHTLCZ_new(uint32_tArray elems) {
- LDKCVec_UpdateFulfillHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateFulfillHTLCZ), "LDKCVec_UpdateFulfillHTLCZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKUpdateFulfillHTLC) * ret->datalen, "LDKCVec_UpdateFulfillHTLCZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKUpdateFulfillHTLC arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = UpdateFulfillHTLC_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_UpdateFulfillHTLCZ CVec_UpdateFulfillHTLCZ_clone(const LDKCVec_UpdateFulfillHTLCZ *orig) {
LDKCVec_UpdateFulfillHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFulfillHTLC) * orig->datalen, "LDKCVec_UpdateFulfillHTLCZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_UpdateFailHTLCZ_new(uint32_tArray elems) {
- LDKCVec_UpdateFailHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateFailHTLCZ), "LDKCVec_UpdateFailHTLCZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKUpdateFailHTLC) * ret->datalen, "LDKCVec_UpdateFailHTLCZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKUpdateFailHTLC arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = UpdateFailHTLC_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_UpdateFailHTLCZ CVec_UpdateFailHTLCZ_clone(const LDKCVec_UpdateFailHTLCZ *orig) {
LDKCVec_UpdateFailHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailHTLC) * orig->datalen, "LDKCVec_UpdateFailHTLCZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_UpdateFailMalformedHTLCZ_new(uint32_tArray elems) {
- LDKCVec_UpdateFailMalformedHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateFailMalformedHTLCZ), "LDKCVec_UpdateFailMalformedHTLCZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKUpdateFailMalformedHTLC) * ret->datalen, "LDKCVec_UpdateFailMalformedHTLCZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKUpdateFailMalformedHTLC arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = UpdateFailMalformedHTLC_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_UpdateFailMalformedHTLCZ CVec_UpdateFailMalformedHTLCZ_clone(const LDKCVec_UpdateFailMalformedHTLCZ *orig) {
LDKCVec_UpdateFailMalformedHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailMalformedHTLC) * orig->datalen, "LDKCVec_UpdateFailMalformedHTLCZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
}
return ret;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_AcceptChannelDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_AcceptChannelDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_AcceptChannelDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_AcceptChannelDecodeErrorZ *val = (LDKCResult_AcceptChannelDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_AnnouncementSignaturesDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_AnnouncementSignaturesDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_AnnouncementSignaturesDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_AnnouncementSignaturesDecodeErrorZ *val = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelReestablishDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ChannelReestablishDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelReestablishDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ChannelReestablishDecodeErrorZ *val = (LDKCResult_ChannelReestablishDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ClosingSignedDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ClosingSignedDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ClosingSignedDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ClosingSignedDecodeErrorZ *val = (LDKCResult_ClosingSignedDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ClosingSignedFeeRangeDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *val = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_CommitmentSignedDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_CommitmentSignedDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_CommitmentSignedDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_CommitmentSignedDecodeErrorZ *val = (LDKCResult_CommitmentSignedDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_FundingCreatedDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_FundingCreatedDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_FundingCreatedDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_FundingCreatedDecodeErrorZ *val = (LDKCResult_FundingCreatedDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_FundingSignedDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_FundingSignedDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_FundingSignedDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_FundingSignedDecodeErrorZ *val = (LDKCResult_FundingSignedDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_FundingLockedDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_FundingLockedDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_FundingLockedDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_FundingLockedDecodeErrorZ *val = (LDKCResult_FundingLockedDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_InitDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_InitDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InitDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_InitDecodeErrorZ *val = (LDKCResult_InitDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_OpenChannelDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_OpenChannelDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_OpenChannelDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_OpenChannelDecodeErrorZ *val = (LDKCResult_OpenChannelDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_RevokeAndACKDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_RevokeAndACKDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RevokeAndACKDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_RevokeAndACKDecodeErrorZ *val = (LDKCResult_RevokeAndACKDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ShutdownDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ShutdownDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ShutdownDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ShutdownDecodeErrorZ *val = (LDKCResult_ShutdownDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_UpdateFailHTLCDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_UpdateFailHTLCDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UpdateFailHTLCDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_UpdateFailHTLCDecodeErrorZ *val = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *val = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_UpdateFeeDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_UpdateFeeDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UpdateFeeDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_UpdateFeeDecodeErrorZ *val = (LDKCResult_UpdateFeeDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_UpdateFulfillHTLCDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_UpdateFulfillHTLCDecodeErrorZ *val = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_UpdateAddHTLCDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_UpdateAddHTLCDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UpdateAddHTLCDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_UpdateAddHTLCDecodeErrorZ *val = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_PingDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_PingDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PingDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_PingDecodeErrorZ *val = (LDKCResult_PingDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_PongDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_PongDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PongDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_PongDecodeErrorZ *val = (LDKCResult_PongDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *val = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelAnnouncementDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ChannelAnnouncementDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelAnnouncementDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ChannelAnnouncementDecodeErrorZ *val = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_UnsignedChannelUpdateDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_UnsignedChannelUpdateDecodeErrorZ *val = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelUpdateDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ChannelUpdateDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelUpdateDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ChannelUpdateDecodeErrorZ *val = (LDKCResult_ChannelUpdateDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ErrorMessageDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ErrorMessageDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ErrorMessageDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ErrorMessageDecodeErrorZ *val = (LDKCResult_ErrorMessageDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *val = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_NodeAnnouncementDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_NodeAnnouncementDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NodeAnnouncementDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_NodeAnnouncementDecodeErrorZ *val = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_QueryShortChannelIdsDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_QueryShortChannelIdsDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_QueryShortChannelIdsDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_QueryShortChannelIdsDecodeErrorZ *val = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *val = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_QueryChannelRangeDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_QueryChannelRangeDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_QueryChannelRangeDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_QueryChannelRangeDecodeErrorZ *val = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_ReplyChannelRangeDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_ReplyChannelRangeDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ReplyChannelRangeDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_ReplyChannelRangeDecodeErrorZ *val = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_GossipTimestampFilterDecodeErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_GossipTimestampFilterDecodeErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_GossipTimestampFilterDecodeErrorZ_get_ok(uint32_t arg) {
LDKCResult_GossipTimestampFilterDecodeErrorZ *val = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t err_ref = 0;
CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(err_var);
err_ref = (uint64_t)err_var.inner & ~1;
return err_ref;
}
default: abort();
}
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_InvoiceSignOrCreationErrorZ_result_ok(uint32_t arg) {
- return ((LDKCResult_InvoiceSignOrCreationErrorZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InvoiceSignOrCreationErrorZ_get_ok(uint32_t arg) {
LDKCResult_InvoiceSignOrCreationErrorZ *val = (LDKCResult_InvoiceSignOrCreationErrorZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
uint64_t output_ref = 0;
CHECK((((uint64_t)output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(output_var);
output_ref = (uint64_t)output_var.inner;
if (output_var.is_owned) {
output_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCOption_C2Tuple_usizeTransactionZZ ret_conv = *(LDKCOption_C2Tuple_usizeTransactionZZ*)(ret_ptr);
- ret_conv = COption_C2Tuple_usizeTransactionZZ_clone((LDKCOption_C2Tuple_usizeTransactionZZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
static void LDKFilter_JCalls_cloned(LDKFilter* new_obj) {
LDKWatchedOutput output_conv;
output_conv.inner = (void*)(output & (~1));
output_conv.is_owned = (output & 1) || (output == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(output_conv);
output_conv = WatchedOutput_clone(&output_conv);
LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
*ret_copy = (this_arg_conv->register_output)(this_arg_conv->this_arg, output_conv);
default: abort();
}
}
-jboolean __attribute__((visibility("default"))) TS_LDKCResult_LockedChannelMonitorNoneZ_result_ok(uint32_t arg) {
- return ((LDKCResult_LockedChannelMonitorNoneZ*)arg)->result_ok;
-}
uint32_t __attribute__((visibility("default"))) TS_LDKCResult_LockedChannelMonitorNoneZ_get_ok(uint32_t arg) {
LDKCResult_LockedChannelMonitorNoneZ *val = (LDKCResult_LockedChannelMonitorNoneZ*)(arg & ~1);
CHECK(val->result_ok);
uint64_t res_ref = 0;
CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(res_var);
res_ref = (uint64_t)res_var.inner & ~1;
return res_ref;
}
CHECK(!val->result_ok);
return *val->contents.err;
}
-uint32_t __attribute__((visibility("default"))) TS_LDKCVec_OutPointZ_new(uint32_tArray elems) {
- LDKCVec_OutPointZ *ret = MALLOC(sizeof(LDKCVec_OutPointZ), "LDKCVec_OutPointZ");
- ret->datalen = *((uint32_t*)elems);
- if (ret->datalen == 0) {
- ret->data = NULL;
- } else {
- ret->data = MALLOC(sizeof(LDKOutPoint) * ret->datalen, "LDKCVec_OutPointZ Data");
- uint32_t *java_elems = (uint32_t*)(elems + 4);
- for (size_t i = 0; i < ret->datalen; i++) {
- uint32_t arr_elem = java_elems[i];
- LDKOutPoint arr_elem_conv;
- arr_elem_conv.inner = (void*)(arr_elem & (~1));
- arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
- arr_elem_conv = OutPoint_clone(&arr_elem_conv);
- ret->data[i] = arr_elem_conv;
- }
- }
- return (uint64_t)ret;
-}
static inline LDKCVec_OutPointZ CVec_OutPointZ_clone(const LDKCVec_OutPointZ *orig) {
LDKCVec_OutPointZ ret = { .data = MALLOC(sizeof(LDKOutPoint) * orig->datalen, "LDKCVec_OutPointZ clone bytes"), .datalen = orig->datalen };
for (size_t i = 0; i < ret.datalen; i++) {
void* ret_conv_18_ptr = (void*)(((uint64_t)ret_conv_18) & ~1);
CHECK_ACCESS(ret_conv_18_ptr);
LDKMessageSendEvent ret_conv_18_conv = *(LDKMessageSendEvent*)(ret_conv_18_ptr);
- ret_conv_18_conv = MessageSendEvent_clone((LDKMessageSendEvent*)(((uint64_t)ret_conv_18) & ~1));
+ FREE((void*)ret_conv_18);
ret_constr.data[s] = ret_conv_18_conv;
}
return ret_constr;
uint64_t channel_id_ref = 0;
CHECK((((uint64_t)channel_id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&channel_id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_var);
channel_id_ref = (uint64_t)channel_id_var.inner;
if (channel_id_var.is_owned) {
channel_id_ref |= 1;
data_var = ChannelMonitor_clone(data);
CHECK((((uint64_t)data_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&data_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(data_var);
data_ref = (uint64_t)data_var.inner;
if (data_var.is_owned) {
data_ref |= 1;
uint64_t update_id_ref = 0;
CHECK((((uint64_t)update_id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_var);
update_id_ref = (uint64_t)update_id_var.inner;
if (update_id_var.is_owned) {
update_id_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(ret_ptr);
- ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_NoneChannelMonitorUpdateErrZ update_persisted_channel_LDKPersist_jcall(const void* this_arg, LDKOutPoint channel_id, const LDKChannelMonitorUpdate * update, const LDKChannelMonitor * data, LDKMonitorUpdateId update_id) {
uint64_t channel_id_ref = 0;
CHECK((((uint64_t)channel_id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&channel_id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_var);
channel_id_ref = (uint64_t)channel_id_var.inner;
if (channel_id_var.is_owned) {
channel_id_ref |= 1;
update_var = ChannelMonitorUpdate_clone(update);
CHECK((((uint64_t)update_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_var);
update_ref = (uint64_t)update_var.inner;
if (update_var.is_owned) {
update_ref |= 1;
data_var = ChannelMonitor_clone(data);
CHECK((((uint64_t)data_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&data_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(data_var);
data_ref = (uint64_t)data_var.inner;
if (data_var.is_owned) {
data_ref |= 1;
uint64_t update_id_ref = 0;
CHECK((((uint64_t)update_id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&update_id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_var);
update_id_ref = (uint64_t)update_id_var.inner;
if (update_id_var.is_owned) {
update_id_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(ret_ptr);
- ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
static void LDKPersist_JCalls_cloned(LDKPersist* new_obj) {
LDKOutPoint channel_id_conv;
channel_id_conv.inner = (void*)(channel_id & (~1));
channel_id_conv.is_owned = (channel_id & 1) || (channel_id == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_conv);
channel_id_conv = OutPoint_clone(&channel_id_conv);
LDKChannelMonitor data_conv;
data_conv.inner = (void*)(data & (~1));
data_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(data_conv);
LDKMonitorUpdateId update_id_conv;
update_id_conv.inner = (void*)(update_id & (~1));
update_id_conv.is_owned = (update_id & 1) || (update_id == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_conv);
update_id_conv = MonitorUpdateId_clone(&update_id_conv);
LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
*ret_conv = (this_arg_conv->persist_new_channel)(this_arg_conv->this_arg, channel_id_conv, &data_conv, update_id_conv);
LDKOutPoint channel_id_conv;
channel_id_conv.inner = (void*)(channel_id & (~1));
channel_id_conv.is_owned = (channel_id & 1) || (channel_id == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_conv);
channel_id_conv = OutPoint_clone(&channel_id_conv);
LDKChannelMonitorUpdate update_conv;
update_conv.inner = (void*)(update & (~1));
update_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_conv);
LDKChannelMonitor data_conv;
data_conv.inner = (void*)(data & (~1));
data_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(data_conv);
LDKMonitorUpdateId update_id_conv;
update_id_conv.inner = (void*)(update_id & (~1));
update_id_conv.is_owned = (update_id & 1) || (update_id == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_conv);
update_id_conv = MonitorUpdateId_clone(&update_id_conv);
LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
*ret_conv = (this_arg_conv->update_persisted_channel)(this_arg_conv->this_arg, channel_id_conv, &update_conv, &data_conv, update_id_conv);
uint64_t their_features_ref = 0;
CHECK((((uint64_t)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_var);
their_features_ref = (uint64_t)their_features_var.inner;
if (their_features_var.is_owned) {
their_features_ref |= 1;
msg_var = OpenChannel_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
uint64_t their_features_ref = 0;
CHECK((((uint64_t)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_var);
their_features_ref = (uint64_t)their_features_var.inner;
if (their_features_var.is_owned) {
their_features_ref |= 1;
msg_var = AcceptChannel_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = FundingCreated_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = FundingSigned_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = FundingLocked_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
their_features_var = InitFeatures_clone(their_features);
CHECK((((uint64_t)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_var);
their_features_ref = (uint64_t)their_features_var.inner;
if (their_features_var.is_owned) {
their_features_ref |= 1;
msg_var = Shutdown_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = ClosingSigned_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = UpdateAddHTLC_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = UpdateFulfillHTLC_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = UpdateFailHTLC_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = UpdateFailMalformedHTLC_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = CommitmentSigned_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = RevokeAndACK_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = UpdateFee_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = AnnouncementSignatures_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = Init_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = ChannelReestablish_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = ChannelUpdate_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
msg_var = ErrorMessage_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
LDKInitFeatures their_features_conv;
their_features_conv.inner = (void*)(their_features & (~1));
their_features_conv.is_owned = (their_features & 1) || (their_features == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_conv);
their_features_conv = InitFeatures_clone(&their_features_conv);
LDKOpenChannel msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_open_channel)(this_arg_conv->this_arg, their_node_id_ref, their_features_conv, &msg_conv);
}
LDKInitFeatures their_features_conv;
their_features_conv.inner = (void*)(their_features & (~1));
their_features_conv.is_owned = (their_features & 1) || (their_features == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_conv);
their_features_conv = InitFeatures_clone(&their_features_conv);
LDKAcceptChannel msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_accept_channel)(this_arg_conv->this_arg, their_node_id_ref, their_features_conv, &msg_conv);
}
LDKFundingCreated msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_funding_created)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKFundingSigned msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_funding_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKFundingLocked msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_funding_locked)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKInitFeatures their_features_conv;
their_features_conv.inner = (void*)(their_features & (~1));
their_features_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_conv);
LDKShutdown msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_shutdown)(this_arg_conv->this_arg, their_node_id_ref, &their_features_conv, &msg_conv);
}
LDKClosingSigned msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_closing_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKUpdateAddHTLC msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_update_add_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKUpdateFulfillHTLC msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_update_fulfill_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKUpdateFailHTLC msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_update_fail_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKUpdateFailMalformedHTLC msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_update_fail_malformed_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKCommitmentSigned msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_commitment_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKRevokeAndACK msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_revoke_and_ack)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKUpdateFee msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_update_fee)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKAnnouncementSignatures msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_announcement_signatures)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKInit msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->peer_connected)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKChannelReestablish msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_channel_reestablish)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
LDKErrorMessage msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
(this_arg_conv->handle_error)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
}
msg_var = NodeAnnouncement_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_boolLightningErrorZ handle_channel_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKChannelAnnouncement * msg) {
msg_var = ChannelAnnouncement_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_boolLightningErrorZ handle_channel_update_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKChannelUpdate * msg) {
msg_var = ChannelUpdate_clone(msg);
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcements_LDKRoutingMessageHandler_jcall(const void* this_arg, uint64_t starting_point, uint8_t batch_amount) {
void* ret_conv_59_ptr = (void*)(((uint64_t)ret_conv_59) & ~1);
CHECK_ACCESS(ret_conv_59_ptr);
LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ ret_conv_59_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ret_conv_59_ptr);
- ret_conv_59_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone((LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)ret_conv_59) & ~1));
+ FREE((void*)ret_conv_59);
ret_constr.data[h] = ret_conv_59_conv;
}
return ret_constr;
LDKNodeAnnouncement ret_conv_18_conv;
ret_conv_18_conv.inner = (void*)(ret_conv_18 & (~1));
ret_conv_18_conv.is_owned = (ret_conv_18 & 1) || (ret_conv_18 == 0);
- ret_conv_18_conv = NodeAnnouncement_clone(&ret_conv_18_conv);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_18_conv);
ret_constr.data[s] = ret_conv_18_conv;
}
return ret_constr;
init_var = Init_clone(init);
CHECK((((uint64_t)init_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&init_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(init_var);
init_ref = (uint64_t)init_var.inner;
if (init_var.is_owned) {
init_ref |= 1;
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_NoneLightningErrorZ handle_reply_short_channel_ids_end_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyShortChannelIdsEnd msg) {
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_NoneLightningErrorZ handle_query_channel_range_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryChannelRange msg) {
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_NoneLightningErrorZ handle_query_short_channel_ids_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryShortChannelIds msg) {
uint64_t msg_ref = 0;
CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
msg_ref = (uint64_t)msg_var.inner;
if (msg_var.is_owned) {
msg_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
static void LDKRoutingMessageHandler_JCalls_cloned(LDKRoutingMessageHandler* new_obj) {
LDKNodeAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
*ret_conv = (this_arg_conv->handle_node_announcement)(this_arg_conv->this_arg, &msg_conv);
return (uint64_t)ret_conv;
LDKChannelAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
*ret_conv = (this_arg_conv->handle_channel_announcement)(this_arg_conv->this_arg, &msg_conv);
return (uint64_t)ret_conv;
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
*ret_conv = (this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, &msg_conv);
return (uint64_t)ret_conv;
uint64_t ret_conv_18_ref = 0;
CHECK((((uint64_t)ret_conv_18_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_18_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_18_var);
ret_conv_18_ref = (uint64_t)ret_conv_18_var.inner;
if (ret_conv_18_var.is_owned) {
ret_conv_18_ref |= 1;
LDKInit init_conv;
init_conv.inner = (void*)(init & (~1));
init_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(init_conv);
(this_arg_conv->sync_routing_table)(this_arg_conv->this_arg, their_node_id_ref, &init_conv);
}
LDKReplyChannelRange msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ReplyChannelRange_clone(&msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = (this_arg_conv->handle_reply_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
LDKReplyShortChannelIdsEnd msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ReplyShortChannelIdsEnd_clone(&msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = (this_arg_conv->handle_reply_short_channel_ids_end)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
LDKQueryChannelRange msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = QueryChannelRange_clone(&msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = (this_arg_conv->handle_query_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
LDKQueryShortChannelIds msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = QueryShortChannelIds_clone(&msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = (this_arg_conv->handle_query_short_channel_ids)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_COption_TypeZDecodeErrorZ ret_conv = *(LDKCResult_COption_TypeZDecodeErrorZ*)(ret_ptr);
- ret_conv = CResult_COption_TypeZDecodeErrorZ_clone((LDKCResult_COption_TypeZDecodeErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
static void LDKCustomMessageReader_JCalls_cloned(LDKCustomMessageReader* new_obj) {
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg_LDKCustomMessageHandler_jcall(const void* this_arg) {
void* ret_conv_25_ptr = (void*)(((uint64_t)ret_conv_25) & ~1);
CHECK_ACCESS(ret_conv_25_ptr);
LDKC2Tuple_PublicKeyTypeZ ret_conv_25_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(ret_conv_25_ptr);
- ret_conv_25_conv = C2Tuple_PublicKeyTypeZ_clone((LDKC2Tuple_PublicKeyTypeZ*)(((uint64_t)ret_conv_25) & ~1));
+ FREE((void*)ret_conv_25);
ret_constr.data[z] = ret_conv_25_conv;
}
return ret_constr;
source_var = NodeId_clone(source);
CHECK((((uint64_t)source_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&source_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(source_var);
source_ref = (uint64_t)source_var.inner;
if (source_var.is_owned) {
source_ref |= 1;
target_var = NodeId_clone(target);
CHECK((((uint64_t)target_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&target_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(target_var);
target_ref = (uint64_t)target_var.inner;
if (target_var.is_owned) {
target_ref |= 1;
uint64_t path_conv_10_ref = 0;
CHECK((((uint64_t)path_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&path_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
path_conv_10_ref = (uint64_t)path_conv_10_var.inner;
if (path_conv_10_var.is_owned) {
path_conv_10_ref |= 1;
LDKNodeId source_conv;
source_conv.inner = (void*)(source & (~1));
source_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(source_conv);
LDKNodeId target_conv;
target_conv.inner = (void*)(target & (~1));
target_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
int64_t ret_val = (this_arg_conv->channel_penalty_msat)(this_arg_conv->this_arg, short_channel_id, &source_conv, &target_conv);
return ret_val;
}
LDKRouteHop path_conv_10_conv;
path_conv_10_conv.inner = (void*)(path_conv_10 & (~1));
path_conv_10_conv.is_owned = (path_conv_10 & 1) || (path_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
path_constr.data[k] = path_conv_10_conv;
}
// Warning: we may need a move here but no clone is available for LDKChannelManager
CHECK((((uint64_t)channel_manager_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&channel_manager_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_manager_var);
channel_manager_ref = (uint64_t)channel_manager_var.inner;
if (channel_manager_var.is_owned) {
channel_manager_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NoneErrorZ ret_conv = *(LDKCResult_NoneErrorZ*)(ret_ptr);
- ret_conv = CResult_NoneErrorZ_clone((LDKCResult_NoneErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
static void LDKChannelManagerPersister_JCalls_cloned(LDKChannelManagerPersister* new_obj) {
LDKChannelManager channel_manager_conv;
channel_manager_conv.inner = (void*)(channel_manager & (~1));
channel_manager_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_manager_conv);
LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
*ret_conv = (this_arg_conv->persist_manager)(this_arg_conv->this_arg, &channel_manager_conv);
return (uint64_t)ret_conv;
LDKChannelDetails ret_conv_16_conv;
ret_conv_16_conv.inner = (void*)(ret_conv_16 & (~1));
ret_conv_16_conv.is_owned = (ret_conv_16 & 1) || (ret_conv_16 == 0);
- ret_conv_16_conv = ChannelDetails_clone(&ret_conv_16_conv);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_conv);
ret_constr.data[q] = ret_conv_16_conv;
}
return ret_constr;
route_var = Route_clone(route);
CHECK((((uint64_t)route_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&route_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_var);
route_ref = (uint64_t)route_var.inner;
if (route_var.is_owned) {
route_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_PaymentIdPaymentSendFailureZ ret_conv = *(LDKCResult_PaymentIdPaymentSendFailureZ*)(ret_ptr);
- ret_conv = CResult_PaymentIdPaymentSendFailureZ_clone((LDKCResult_PaymentIdPaymentSendFailureZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
LDKCResult_NonePaymentSendFailureZ retry_payment_LDKPayer_jcall(const void* this_arg, const LDKRoute * route, LDKThirtyTwoBytes payment_id) {
route_var = Route_clone(route);
CHECK((((uint64_t)route_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&route_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_var);
route_ref = (uint64_t)route_var.inner;
if (route_var.is_owned) {
route_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_NonePaymentSendFailureZ ret_conv = *(LDKCResult_NonePaymentSendFailureZ*)(ret_ptr);
- ret_conv = CResult_NonePaymentSendFailureZ_clone((LDKCResult_NonePaymentSendFailureZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
static void LDKPayer_JCalls_cloned(LDKPayer* new_obj) {
uint64_t ret_conv_16_ref = 0;
CHECK((((uint64_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
ret_conv_16_ref = (uint64_t)ret_conv_16_var.inner;
if (ret_conv_16_var.is_owned) {
ret_conv_16_ref |= 1;
LDKRoute route_conv;
route_conv.inner = (void*)(route & (~1));
route_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
LDKThirtyTwoBytes payment_hash_ref;
CHECK(*((uint32_t*)payment_hash) == 32);
memcpy(payment_hash_ref.data, (uint8_t*)(payment_hash + 4), 32);
LDKRoute route_conv;
route_conv.inner = (void*)(route & (~1));
route_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
LDKThirtyTwoBytes payment_id_ref;
CHECK(*((uint32_t*)payment_id) == 32);
memcpy(payment_id_ref.data, (uint8_t*)(payment_id + 4), 32);
params_var = RouteParameters_clone(params);
CHECK((((uint64_t)params_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)¶ms_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(params_var);
params_ref = (uint64_t)params_var.inner;
if (params_var.is_owned) {
params_ref |= 1;
uint64_t first_hops_conv_16_ref = 0;
CHECK((((uint64_t)first_hops_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&first_hops_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_var);
first_hops_conv_16_ref = (uint64_t)first_hops_conv_16_var.inner;
if (first_hops_conv_16_var.is_owned) {
first_hops_conv_16_ref |= 1;
void* ret_ptr = (void*)(((uint64_t)ret) & ~1);
CHECK_ACCESS(ret_ptr);
LDKCResult_RouteLightningErrorZ ret_conv = *(LDKCResult_RouteLightningErrorZ*)(ret_ptr);
- ret_conv = CResult_RouteLightningErrorZ_clone((LDKCResult_RouteLightningErrorZ*)(((uint64_t)ret) & ~1));
+ FREE((void*)ret);
return ret_conv;
}
static void LDKRouter_JCalls_cloned(LDKRouter* new_obj) {
LDKRouteParameters params_conv;
params_conv.inner = (void*)(params & (~1));
params_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
LDKCVec_ChannelDetailsZ first_hops_constr;
LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL;
if (first_hops != 0) {
LDKChannelDetails first_hops_conv_16_conv;
first_hops_conv_16_conv.inner = (void*)(first_hops_conv_16 & (~1));
first_hops_conv_16_conv.is_owned = (first_hops_conv_16 & 1) || (first_hops_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_conv);
first_hops_constr.data[q] = first_hops_conv_16_conv;
}
first_hops_ptr = &first_hops_constr;
TxOut_free(_res_conv);
}
+static inline uint64_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg) {
+ LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
+ *ret_ref = TxOut_clone(arg);
+ return (uint64_t)ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_TxOut_clone_ptr(uint32_t arg) {
+ LDKTxOut* arg_conv = (LDKTxOut*)(arg & ~1);
+ int64_t ret_val = TxOut_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_TxOut_clone(uint32_t orig) {
LDKTxOut* orig_conv = (LDKTxOut*)(orig & ~1);
LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_SecretKeyErrorZ_is_ok(uint32_t o) {
+ LDKCResult_SecretKeyErrorZ* o_conv = (LDKCResult_SecretKeyErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_SecretKeyErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_SecretKeyErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_PublicKeyErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PublicKeyErrorZ* o_conv = (LDKCResult_PublicKeyErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PublicKeyErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_PublicKeyErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PublicKeyErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
+ *ret_conv = CResult_PublicKeyErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PublicKeyErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PublicKeyErrorZ* arg_conv = (LDKCResult_PublicKeyErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PublicKeyErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_PublicKeyErrorZ_clone(uint32_t orig) {
LDKCResult_PublicKeyErrorZ* orig_conv = (LDKCResult_PublicKeyErrorZ*)(orig & ~1);
LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
LDKTxCreationKeys o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = TxCreationKeys_clone(&o_conv);
LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
*ret_conv = CResult_TxCreationKeysDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
*ret_conv = CResult_TxCreationKeysDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_TxCreationKeysDecodeErrorZ* o_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_TxCreationKeysDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_TxCreationKeysDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_TxCreationKeysDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
+ *ret_conv = CResult_TxCreationKeysDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_TxCreationKeysDecodeErrorZ* arg_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_TxCreationKeysDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_TxCreationKeysDecodeErrorZ* orig_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)(orig & ~1);
LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
LDKChannelPublicKeys o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelPublicKeys_clone(&o_conv);
LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
*ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
*ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelPublicKeysDecodeErrorZ* o_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelPublicKeysDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
+ *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ChannelPublicKeysDecodeErrorZ* arg_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ChannelPublicKeysDecodeErrorZ* orig_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
LDKTxCreationKeys o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = TxCreationKeys_clone(&o_conv);
LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
*ret_conv = CResult_TxCreationKeysErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_TxCreationKeysErrorZ_is_ok(uint32_t o) {
+ LDKCResult_TxCreationKeysErrorZ* o_conv = (LDKCResult_TxCreationKeysErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_TxCreationKeysErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_TxCreationKeysErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_TxCreationKeysErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_TxCreationKeysErrorZ_clone_ptr(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR arg) {
+ LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
+ *ret_conv = CResult_TxCreationKeysErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_TxCreationKeysErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_TxCreationKeysErrorZ* arg_conv = (LDKCResult_TxCreationKeysErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_TxCreationKeysErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_TxCreationKeysErrorZ_clone(uint32_t orig) {
LDKCResult_TxCreationKeysErrorZ* orig_conv = (LDKCResult_TxCreationKeysErrorZ*)(orig & ~1);
LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
COption_u32Z_free(_res_conv);
}
+static inline uint64_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg) {
+ LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
+ *ret_copy = COption_u32Z_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_u32Z_clone_ptr(uint32_t arg) {
+ LDKCOption_u32Z* arg_conv = (LDKCOption_u32Z*)arg;
+ int64_t ret_val = COption_u32Z_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_COption_u32Z_clone(uint32_t orig) {
LDKCOption_u32Z* orig_conv = (LDKCOption_u32Z*)orig;
LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
LDKHTLCOutputInCommitment o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = HTLCOutputInCommitment_clone(&o_conv);
LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
*ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
*ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* o_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
+ *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* arg_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* orig_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(orig & ~1);
LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
LDKCounterpartyChannelTransactionParameters o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = CounterpartyChannelTransactionParameters_clone(&o_conv);
LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
*ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
*ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* o_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
+ *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* arg_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(orig & ~1);
LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
LDKChannelTransactionParameters o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelTransactionParameters_clone(&o_conv);
LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
*ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
*ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelTransactionParametersDecodeErrorZ* o_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelTransactionParametersDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
+ *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ChannelTransactionParametersDecodeErrorZ* arg_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
LDKHolderCommitmentTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = HolderCommitmentTransaction_clone(&o_conv);
LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_HolderCommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
+ *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_HolderCommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_HolderCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(orig & ~1);
LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
LDKBuiltCommitmentTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = BuiltCommitmentTransaction_clone(&o_conv);
LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
+ *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(orig & ~1);
LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
LDKTrustedClosingTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
// Warning: we need a move here but no clone is available for LDKTrustedClosingTransaction
LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
*ret_conv = CResult_TrustedClosingTransactionNoneZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_TrustedClosingTransactionNoneZ_is_ok(uint32_t o) {
+ LDKCResult_TrustedClosingTransactionNoneZ* o_conv = (LDKCResult_TrustedClosingTransactionNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_TrustedClosingTransactionNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_TrustedClosingTransactionNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKCommitmentTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = CommitmentTransaction_clone(&o_conv);
LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_CommitmentTransactionDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
*ret_conv = CResult_CommitmentTransactionDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_CommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CommitmentTransactionDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_CommitmentTransactionDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CommitmentTransactionDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
+ *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_CommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_CommitmentTransactionDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_CommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(orig & ~1);
LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
LDKTrustedCommitmentTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
// Warning: we need a move here but no clone is available for LDKTrustedCommitmentTransaction
LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
*ret_conv = CResult_TrustedCommitmentTransactionNoneZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(uint32_t o) {
+ LDKCResult_TrustedCommitmentTransactionNoneZ* o_conv = (LDKCResult_TrustedCommitmentTransactionNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_TrustedCommitmentTransactionNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_TrustedCommitmentTransactionNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_CVec_SignatureZNoneZ_is_ok(uint32_t o) {
+ LDKCResult_CVec_SignatureZNoneZ* o_conv = (LDKCResult_CVec_SignatureZNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_CVec_SignatureZNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_CVec_SignatureZNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CVec_SignatureZNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg) {
+ LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
+ *ret_conv = CResult_CVec_SignatureZNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_CVec_SignatureZNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_CVec_SignatureZNoneZ* arg_conv = (LDKCResult_CVec_SignatureZNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_CVec_SignatureZNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_SignatureZNoneZ_clone(uint32_t orig) {
LDKCResult_CVec_SignatureZNoneZ* orig_conv = (LDKCResult_CVec_SignatureZNoneZ*)(orig & ~1);
LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
LDKShutdownScript o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ShutdownScript_clone(&o_conv);
LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
*ret_conv = CResult_ShutdownScriptDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
*ret_conv = CResult_ShutdownScriptDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ShutdownScriptDecodeErrorZ* o_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ShutdownScriptDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ShutdownScriptDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ShutdownScriptDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
+ *ret_conv = CResult_ShutdownScriptDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ShutdownScriptDecodeErrorZ* arg_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ShutdownScriptDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ShutdownScriptDecodeErrorZ* orig_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)(orig & ~1);
LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
LDKShutdownScript o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ShutdownScript_clone(&o_conv);
LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
*ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o_conv);
LDKInvalidShutdownScript e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = InvalidShutdownScript_clone(&e_conv);
LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
*ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(uint32_t o) {
+ LDKCResult_ShutdownScriptInvalidShutdownScriptZ* o_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(o & ~1);
+ jboolean ret_val = CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res_conv);
}
+static inline uint64_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg) {
+ LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
+ *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ShutdownScriptInvalidShutdownScriptZ* arg_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(arg & ~1);
+ int64_t ret_val = CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(uint32_t orig) {
LDKCResult_ShutdownScriptInvalidShutdownScriptZ* orig_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(orig & ~1);
LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NoneErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NoneErrorZ* o_conv = (LDKCResult_NoneErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NoneErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
+ *ret_conv = CResult_NoneErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NoneErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NoneErrorZ* arg_conv = (LDKCResult_NoneErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NoneErrorZ_clone(uint32_t orig) {
LDKCResult_NoneErrorZ* orig_conv = (LDKCResult_NoneErrorZ*)(orig & ~1);
LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
LDKRouteHop o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RouteHop_clone(&o_conv);
LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
*ret_conv = CResult_RouteHopDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
*ret_conv = CResult_RouteHopDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_RouteHopDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_RouteHopDecodeErrorZ* o_conv = (LDKCResult_RouteHopDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteHopDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_RouteHopDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RouteHopDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
+ *ret_conv = CResult_RouteHopDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_RouteHopDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_RouteHopDecodeErrorZ* arg_conv = (LDKCResult_RouteHopDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteHopDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_RouteHopDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_RouteHopDecodeErrorZ* orig_conv = (LDKCResult_RouteHopDecodeErrorZ*)(orig & ~1);
LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
LDKRouteHop _res_conv_10_conv;
_res_conv_10_conv.inner = (void*)(_res_conv_10 & (~1));
_res_conv_10_conv.is_owned = (_res_conv_10 & 1) || (_res_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_10_conv);
_res_constr.data[k] = _res_conv_10_conv;
}
CVec_RouteHopZ_free(_res_constr);
LDKRouteHop _res_conv_12_conv_10_conv;
_res_conv_12_conv_10_conv.inner = (void*)(_res_conv_12_conv_10 & (~1));
_res_conv_12_conv_10_conv.is_owned = (_res_conv_12_conv_10 & 1) || (_res_conv_12_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_12_conv_10_conv);
_res_conv_12_constr.data[k] = _res_conv_12_conv_10_conv;
}
_res_constr.data[m] = _res_conv_12_constr;
LDKRoute o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Route_clone(&o_conv);
LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
*ret_conv = CResult_RouteDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
*ret_conv = CResult_RouteDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_RouteDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_RouteDecodeErrorZ* o_conv = (LDKCResult_RouteDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_RouteDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RouteDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
+ *ret_conv = CResult_RouteDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_RouteDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_RouteDecodeErrorZ* arg_conv = (LDKCResult_RouteDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_RouteDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_RouteDecodeErrorZ* orig_conv = (LDKCResult_RouteDecodeErrorZ*)(orig & ~1);
LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
LDKRouteParameters o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RouteParameters_clone(&o_conv);
LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
*ret_conv = CResult_RouteParametersDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
*ret_conv = CResult_RouteParametersDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_RouteParametersDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_RouteParametersDecodeErrorZ* o_conv = (LDKCResult_RouteParametersDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteParametersDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_RouteParametersDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RouteParametersDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
+ *ret_conv = CResult_RouteParametersDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_RouteParametersDecodeErrorZ* arg_conv = (LDKCResult_RouteParametersDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteParametersDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_RouteParametersDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_RouteParametersDecodeErrorZ* orig_conv = (LDKCResult_RouteParametersDecodeErrorZ*)(orig & ~1);
LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
LDKRouteHint _res_conv_11_conv;
_res_conv_11_conv.inner = (void*)(_res_conv_11 & (~1));
_res_conv_11_conv.is_owned = (_res_conv_11 & 1) || (_res_conv_11 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_11_conv);
_res_constr.data[l] = _res_conv_11_conv;
}
CVec_RouteHintZ_free(_res_constr);
COption_u64Z_free(_res_conv);
}
+static inline uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg) {
+ LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
+ *ret_copy = COption_u64Z_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_u64Z_clone_ptr(uint32_t arg) {
+ LDKCOption_u64Z* arg_conv = (LDKCOption_u64Z*)arg;
+ int64_t ret_val = COption_u64Z_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_COption_u64Z_clone(uint32_t orig) {
LDKCOption_u64Z* orig_conv = (LDKCOption_u64Z*)orig;
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
LDKPayee o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Payee_clone(&o_conv);
LDKCResult_PayeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeeDecodeErrorZ), "LDKCResult_PayeeDecodeErrorZ");
*ret_conv = CResult_PayeeDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_PayeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeeDecodeErrorZ), "LDKCResult_PayeeDecodeErrorZ");
*ret_conv = CResult_PayeeDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_PayeeDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PayeeDecodeErrorZ* o_conv = (LDKCResult_PayeeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PayeeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_PayeeDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PayeeDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PayeeDecodeErrorZ_clone_ptr(LDKCResult_PayeeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PayeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeeDecodeErrorZ), "LDKCResult_PayeeDecodeErrorZ");
+ *ret_conv = CResult_PayeeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PayeeDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PayeeDecodeErrorZ* arg_conv = (LDKCResult_PayeeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PayeeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_PayeeDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_PayeeDecodeErrorZ* orig_conv = (LDKCResult_PayeeDecodeErrorZ*)(orig & ~1);
LDKCResult_PayeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeeDecodeErrorZ), "LDKCResult_PayeeDecodeErrorZ");
LDKRouteHintHop _res_conv_14_conv;
_res_conv_14_conv.inner = (void*)(_res_conv_14 & (~1));
_res_conv_14_conv.is_owned = (_res_conv_14 & 1) || (_res_conv_14 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_14_conv);
_res_constr.data[o] = _res_conv_14_conv;
}
CVec_RouteHintHopZ_free(_res_constr);
LDKRouteHint o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RouteHint_clone(&o_conv);
LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
*ret_conv = CResult_RouteHintDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
*ret_conv = CResult_RouteHintDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_RouteHintDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_RouteHintDecodeErrorZ* o_conv = (LDKCResult_RouteHintDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteHintDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_RouteHintDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RouteHintDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
+ *ret_conv = CResult_RouteHintDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_RouteHintDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_RouteHintDecodeErrorZ* arg_conv = (LDKCResult_RouteHintDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteHintDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_RouteHintDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_RouteHintDecodeErrorZ* orig_conv = (LDKCResult_RouteHintDecodeErrorZ*)(orig & ~1);
LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
LDKRouteHintHop o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RouteHintHop_clone(&o_conv);
LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
*ret_conv = CResult_RouteHintHopDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
*ret_conv = CResult_RouteHintHopDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_RouteHintHopDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_RouteHintHopDecodeErrorZ* o_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteHintHopDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_RouteHintHopDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RouteHintHopDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
+ *ret_conv = CResult_RouteHintHopDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_RouteHintHopDecodeErrorZ* arg_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_RouteHintHopDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_RouteHintHopDecodeErrorZ* orig_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)(orig & ~1);
LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
LDKChannelDetails _res_conv_16_conv;
_res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
_res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
_res_constr.data[q] = _res_conv_16_conv;
}
CVec_ChannelDetailsZ_free(_res_constr);
LDKRoute o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Route_clone(&o_conv);
LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
*ret_conv = CResult_RouteLightningErrorZ_ok(o_conv);
LDKLightningError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = LightningError_clone(&e_conv);
LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
*ret_conv = CResult_RouteLightningErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
-void __attribute__((visibility("default"))) TS_CResult_RouteLightningErrorZ_free(uint32_t _res) {
- if ((_res & 1) != 0) return;
+jboolean __attribute__((visibility("default"))) TS_CResult_RouteLightningErrorZ_is_ok(uint32_t o) {
+ LDKCResult_RouteLightningErrorZ* o_conv = (LDKCResult_RouteLightningErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RouteLightningErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_RouteLightningErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CHECK_ACCESS(_res_ptr);
LDKCResult_RouteLightningErrorZ _res_conv = *(LDKCResult_RouteLightningErrorZ*)(_res_ptr);
CResult_RouteLightningErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
+ *ret_conv = CResult_RouteLightningErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_RouteLightningErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_RouteLightningErrorZ* arg_conv = (LDKCResult_RouteLightningErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RouteLightningErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_RouteLightningErrorZ_clone(uint32_t orig) {
LDKCResult_RouteLightningErrorZ* orig_conv = (LDKCResult_RouteLightningErrorZ*)(orig & ~1);
LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_TxOutAccessErrorZ_is_ok(uint32_t o) {
+ LDKCResult_TxOutAccessErrorZ* o_conv = (LDKCResult_TxOutAccessErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_TxOutAccessErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_TxOutAccessErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_TxOutAccessErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg) {
+ LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
+ *ret_conv = CResult_TxOutAccessErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_TxOutAccessErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_TxOutAccessErrorZ* arg_conv = (LDKCResult_TxOutAccessErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_TxOutAccessErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_TxOutAccessErrorZ_clone(uint32_t orig) {
LDKCResult_TxOutAccessErrorZ* orig_conv = (LDKCResult_TxOutAccessErrorZ*)(orig & ~1);
LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg) {
+ LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
+ *ret_conv = C2Tuple_usizeTransactionZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_usizeTransactionZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_usizeTransactionZ* arg_conv = (LDKC2Tuple_usizeTransactionZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_usizeTransactionZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C2Tuple_usizeTransactionZ_clone(uint32_t orig) {
LDKC2Tuple_usizeTransactionZ* orig_conv = (LDKC2Tuple_usizeTransactionZ*)(orig & ~1);
LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NoneChannelMonitorUpdateErrZ_is_ok(uint32_t o) {
+ LDKCResult_NoneChannelMonitorUpdateErrZ* o_conv = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneChannelMonitorUpdateErrZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NoneChannelMonitorUpdateErrZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneChannelMonitorUpdateErrZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR arg) {
+ LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
+ *ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NoneChannelMonitorUpdateErrZ* arg_conv = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NoneChannelMonitorUpdateErrZ_clone(uint32_t orig) {
LDKCResult_NoneChannelMonitorUpdateErrZ* orig_conv = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(orig & ~1);
LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
COption_C2Tuple_usizeTransactionZZ_free(_res_conv);
}
+static inline uint64_t COption_C2Tuple_usizeTransactionZZ_clone_ptr(LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR arg) {
+ LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
+ *ret_copy = COption_C2Tuple_usizeTransactionZZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_C2Tuple_usizeTransactionZZ_clone_ptr(uint32_t arg) {
+ LDKCOption_C2Tuple_usizeTransactionZZ* arg_conv = (LDKCOption_C2Tuple_usizeTransactionZZ*)arg;
+ int64_t ret_val = COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_COption_C2Tuple_usizeTransactionZZ_clone(uint32_t orig) {
LDKCOption_C2Tuple_usizeTransactionZZ* orig_conv = (LDKCOption_C2Tuple_usizeTransactionZZ*)orig;
LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
return ret_ref;
}
+uint32_t __attribute__((visibility("default"))) TS_COption_ClosureReasonZ_some(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKClosureReason o_conv = *(LDKClosureReason*)(o_ptr);
+ o_conv = ClosureReason_clone((LDKClosureReason*)(((uint64_t)o) & ~1));
+ LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
+ *ret_copy = COption_ClosureReasonZ_some(o_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_ClosureReasonZ_none() {
+ LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
+ *ret_copy = COption_ClosureReasonZ_none();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_COption_ClosureReasonZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_ClosureReasonZ _res_conv = *(LDKCOption_ClosureReasonZ*)(_res_ptr);
+ FREE((void*)_res);
+ COption_ClosureReasonZ_free(_res_conv);
+}
+
+static inline uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg) {
+ LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
+ *ret_copy = COption_ClosureReasonZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_ClosureReasonZ_clone_ptr(uint32_t arg) {
+ LDKCOption_ClosureReasonZ* arg_conv = (LDKCOption_ClosureReasonZ*)arg;
+ int64_t ret_val = COption_ClosureReasonZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_ClosureReasonZ_clone(uint32_t orig) {
+ LDKCOption_ClosureReasonZ* orig_conv = (LDKCOption_ClosureReasonZ*)orig;
+ LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
+ *ret_copy = COption_ClosureReasonZ_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKCOption_ClosureReasonZ o_conv = *(LDKCOption_ClosureReasonZ*)(o_ptr);
+ o_conv = COption_ClosureReasonZ_clone((LDKCOption_ClosureReasonZ*)(((uint64_t)o) & ~1));
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* o_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ _res_conv = *(LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_COption_ClosureReasonZDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* arg_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* orig_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(orig & ~1);
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
uint32_t __attribute__((visibility("default"))) TS_COption_NetworkUpdateZ_some(uint32_t o) {
void* o_ptr = (void*)(((uint64_t)o) & ~1);
CHECK_ACCESS(o_ptr);
COption_NetworkUpdateZ_free(_res_conv);
}
+static inline uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg) {
+ LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
+ *ret_copy = COption_NetworkUpdateZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_NetworkUpdateZ_clone_ptr(uint32_t arg) {
+ LDKCOption_NetworkUpdateZ* arg_conv = (LDKCOption_NetworkUpdateZ*)arg;
+ int64_t ret_val = COption_NetworkUpdateZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_COption_NetworkUpdateZ_clone(uint32_t orig) {
LDKCOption_NetworkUpdateZ* orig_conv = (LDKCOption_NetworkUpdateZ*)orig;
LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
CVec_SpendableOutputDescriptorZ_free(_res_constr);
}
+uint32_t __attribute__((visibility("default"))) TS_COption_EventZ_some(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKEvent o_conv = *(LDKEvent*)(o_ptr);
+ o_conv = Event_clone((LDKEvent*)(((uint64_t)o) & ~1));
+ LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
+ *ret_copy = COption_EventZ_some(o_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_EventZ_none() {
+ LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
+ *ret_copy = COption_EventZ_none();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_COption_EventZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_EventZ _res_conv = *(LDKCOption_EventZ*)(_res_ptr);
+ FREE((void*)_res);
+ COption_EventZ_free(_res_conv);
+}
+
+static inline uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg) {
+ LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
+ *ret_copy = COption_EventZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_EventZ_clone_ptr(uint32_t arg) {
+ LDKCOption_EventZ* arg_conv = (LDKCOption_EventZ*)arg;
+ int64_t ret_val = COption_EventZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_EventZ_clone(uint32_t orig) {
+ LDKCOption_EventZ* orig_conv = (LDKCOption_EventZ*)orig;
+ LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
+ *ret_copy = COption_EventZ_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_EventZDecodeErrorZ_ok(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKCOption_EventZ o_conv = *(LDKCOption_EventZ*)(o_ptr);
+ o_conv = COption_EventZ_clone((LDKCOption_EventZ*)(((uint64_t)o) & ~1));
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = CResult_COption_EventZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_EventZDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = CResult_COption_EventZDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_COption_EventZDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_COption_EventZDecodeErrorZ* o_conv = (LDKCResult_COption_EventZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_EventZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_COption_EventZDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_COption_EventZDecodeErrorZ _res_conv = *(LDKCResult_COption_EventZDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_COption_EventZDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = CResult_COption_EventZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_COption_EventZDecodeErrorZ* arg_conv = (LDKCResult_COption_EventZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_EventZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_EventZDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_COption_EventZDecodeErrorZ* orig_conv = (LDKCResult_COption_EventZDecodeErrorZ*)(orig & ~1);
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = CResult_COption_EventZDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
void __attribute__((visibility("default"))) TS_CVec_MessageSendEventZ_free(uint32_tArray _res) {
LDKCVec_MessageSendEventZ _res_constr;
_res_constr.datalen = *((uint32_t*)_res);
LDKInitFeatures o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = InitFeatures_clone(&o_conv);
LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
*ret_conv = CResult_InitFeaturesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
*ret_conv = CResult_InitFeaturesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_InitFeaturesDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_InitFeaturesDecodeErrorZ* o_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InitFeaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_InitFeaturesDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKNodeFeatures o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NodeFeatures_clone(&o_conv);
LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
*ret_conv = CResult_NodeFeaturesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
*ret_conv = CResult_NodeFeaturesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NodeFeaturesDecodeErrorZ* o_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeFeaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NodeFeaturesDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKChannelFeatures o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelFeatures_clone(&o_conv);
LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
*ret_conv = CResult_ChannelFeaturesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
*ret_conv = CResult_ChannelFeaturesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelFeaturesDecodeErrorZ* o_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelFeaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ChannelFeaturesDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKInvoiceFeatures o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = InvoiceFeatures_clone(&o_conv);
LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
*ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
*ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_InvoiceFeaturesDecodeErrorZ* o_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKScoringParameters o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
// Warning: we need a move here but no clone is available for LDKScoringParameters
LDKCResult_ScoringParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ScoringParametersDecodeErrorZ), "LDKCResult_ScoringParametersDecodeErrorZ");
*ret_conv = CResult_ScoringParametersDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ScoringParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ScoringParametersDecodeErrorZ), "LDKCResult_ScoringParametersDecodeErrorZ");
*ret_conv = CResult_ScoringParametersDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ScoringParametersDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ScoringParametersDecodeErrorZ* o_conv = (LDKCResult_ScoringParametersDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ScoringParametersDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ScoringParametersDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKScorer o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
// Warning: we need a move here but no clone is available for LDKScorer
LDKCResult_ScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ScorerDecodeErrorZ), "LDKCResult_ScorerDecodeErrorZ");
*ret_conv = CResult_ScorerDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ScorerDecodeErrorZ), "LDKCResult_ScorerDecodeErrorZ");
*ret_conv = CResult_ScorerDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ScorerDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ScorerDecodeErrorZ* o_conv = (LDKCResult_ScorerDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ScorerDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ScorerDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKDelayedPaymentOutputDescriptor o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = DelayedPaymentOutputDescriptor_clone(&o_conv);
LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
*ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
*ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(orig & ~1);
LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
LDKStaticPaymentOutputDescriptor o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = StaticPaymentOutputDescriptor_clone(&o_conv);
LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
*ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
*ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(orig & ~1);
LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
*ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
+ *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_SpendableOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(orig & ~1);
LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NoneNoneZ_is_ok(uint32_t o) {
+ LDKCResult_NoneNoneZ* o_conv = (LDKCResult_NoneNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NoneNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg) {
+ LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
+ *ret_conv = CResult_NoneNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NoneNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NoneNoneZ* arg_conv = (LDKCResult_NoneNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NoneNoneZ_clone(uint32_t orig) {
LDKCResult_NoneNoneZ* orig_conv = (LDKCResult_NoneNoneZ*)(orig & ~1);
LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg) {
+ LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
+ *ret_conv = C2Tuple_SignatureCVec_SignatureZZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_SignatureCVec_SignatureZZ* arg_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C2Tuple_SignatureCVec_SignatureZZ_clone(uint32_t orig) {
LDKC2Tuple_SignatureCVec_SignatureZZ* orig_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(orig & ~1);
LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(uint32_t o) {
+ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* o_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg) {
+ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
+ *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* arg_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(uint32_t orig) {
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* orig_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(orig & ~1);
LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_SignatureNoneZ_is_ok(uint32_t o) {
+ LDKCResult_SignatureNoneZ* o_conv = (LDKCResult_SignatureNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_SignatureNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_SignatureNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_SignatureNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg) {
+ LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
+ *ret_conv = CResult_SignatureNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_SignatureNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_SignatureNoneZ* arg_conv = (LDKCResult_SignatureNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_SignatureNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_SignatureNoneZ_clone(uint32_t orig) {
LDKCResult_SignatureNoneZ* orig_conv = (LDKCResult_SignatureNoneZ*)(orig & ~1);
LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
*ret_conv = CResult_SignDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_SignDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_SignDecodeErrorZ* o_conv = (LDKCResult_SignDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_SignDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_SignDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_SignDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
+ *ret_conv = CResult_SignDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_SignDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_SignDecodeErrorZ* arg_conv = (LDKCResult_SignDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_SignDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_SignDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_SignDecodeErrorZ* orig_conv = (LDKCResult_SignDecodeErrorZ*)(orig & ~1);
LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_RecoverableSignatureNoneZ_is_ok(uint32_t o) {
+ LDKCResult_RecoverableSignatureNoneZ* o_conv = (LDKCResult_RecoverableSignatureNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_RecoverableSignatureNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_RecoverableSignatureNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RecoverableSignatureNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg) {
+ LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
+ *ret_conv = CResult_RecoverableSignatureNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_RecoverableSignatureNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_RecoverableSignatureNoneZ* arg_conv = (LDKCResult_RecoverableSignatureNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_RecoverableSignatureNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_RecoverableSignatureNoneZ_clone(uint32_t orig) {
LDKCResult_RecoverableSignatureNoneZ* orig_conv = (LDKCResult_RecoverableSignatureNoneZ*)(orig & ~1);
LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(uint32_t o) {
+ LDKCResult_CVec_CVec_u8ZZNoneZ* o_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_CVec_CVec_u8ZZNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_CVec_CVec_u8ZZNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CVec_CVec_u8ZZNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg) {
+ LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
+ *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_CVec_CVec_u8ZZNoneZ* arg_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_CVec_u8ZZNoneZ_clone(uint32_t orig) {
LDKCResult_CVec_CVec_u8ZZNoneZ* orig_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(orig & ~1);
LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
LDKInMemorySigner o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = InMemorySigner_clone(&o_conv);
LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
*ret_conv = CResult_InMemorySignerDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
*ret_conv = CResult_InMemorySignerDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_InMemorySignerDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_InMemorySignerDecodeErrorZ* o_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InMemorySignerDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_InMemorySignerDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_InMemorySignerDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
+ *ret_conv = CResult_InMemorySignerDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_InMemorySignerDecodeErrorZ* arg_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_InMemorySignerDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_InMemorySignerDecodeErrorZ* orig_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(orig & ~1);
LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_TransactionNoneZ_is_ok(uint32_t o) {
+ LDKCResult_TransactionNoneZ* o_conv = (LDKCResult_TransactionNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_TransactionNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_TransactionNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_TransactionNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg) {
+ LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
+ *ret_conv = CResult_TransactionNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_TransactionNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_TransactionNoneZ* arg_conv = (LDKCResult_TransactionNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_TransactionNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_TransactionNoneZ_clone(uint32_t orig) {
LDKCResult_TransactionNoneZ* orig_conv = (LDKCResult_TransactionNoneZ*)(orig & ~1);
LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg) {
+ LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
+ *ret_conv = C2Tuple_BlockHashChannelMonitorZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_BlockHashChannelMonitorZ* arg_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelMonitorZ_clone(uint32_t orig) {
LDKC2Tuple_BlockHashChannelMonitorZ* orig_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)(orig & ~1);
LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
LDKChannelMonitor b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = (b & 1) || (b == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
b_conv = ChannelMonitor_clone(&b_conv);
LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
*ret_conv = C2Tuple_BlockHashChannelMonitorZ_new(a_ref, b_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_is_ok(uint32_t o) {
+ LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* o_conv = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone_ptr(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ), "LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ");
+ *ret_conv = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* arg_conv = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone(uint32_t orig) {
LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* orig_conv = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(orig & ~1);
LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ), "LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ");
COption_u16Z_free(_res_conv);
}
+static inline uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg) {
+ LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
+ *ret_copy = COption_u16Z_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_u16Z_clone_ptr(uint32_t arg) {
+ LDKCOption_u16Z* arg_conv = (LDKCOption_u16Z*)arg;
+ int64_t ret_val = COption_u16Z_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_COption_u16Z_clone(uint32_t orig) {
LDKCOption_u16Z* orig_conv = (LDKCOption_u16Z*)orig;
LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NoneAPIErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NoneAPIErrorZ* o_conv = (LDKCResult_NoneAPIErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneAPIErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NoneAPIErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneAPIErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
+ *ret_conv = CResult_NoneAPIErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NoneAPIErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NoneAPIErrorZ* arg_conv = (LDKCResult_NoneAPIErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneAPIErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NoneAPIErrorZ_clone(uint32_t orig) {
LDKCResult_NoneAPIErrorZ* orig_conv = (LDKCResult_NoneAPIErrorZ*)(orig & ~1);
LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult__u832APIErrorZ_is_ok(uint32_t o) {
+ LDKCResult__u832APIErrorZ* o_conv = (LDKCResult__u832APIErrorZ*)(o & ~1);
+ jboolean ret_val = CResult__u832APIErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult__u832APIErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult__u832APIErrorZ_free(_res_conv);
}
+static inline uint64_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg) {
+ LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
+ *ret_conv = CResult__u832APIErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult__u832APIErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult__u832APIErrorZ* arg_conv = (LDKCResult__u832APIErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult__u832APIErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult__u832APIErrorZ_clone(uint32_t orig) {
LDKCResult__u832APIErrorZ* orig_conv = (LDKCResult__u832APIErrorZ*)(orig & ~1);
LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentSendFailureZ_is_ok(uint32_t o) {
+ LDKCResult_PaymentIdPaymentSendFailureZ* o_conv = (LDKCResult_PaymentIdPaymentSendFailureZ*)(o & ~1);
+ jboolean ret_val = CResult_PaymentIdPaymentSendFailureZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentSendFailureZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PaymentIdPaymentSendFailureZ_free(_res_conv);
}
+static inline uint64_t CResult_PaymentIdPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR arg) {
+ LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ");
+ *ret_conv = CResult_PaymentIdPaymentSendFailureZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentSendFailureZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PaymentIdPaymentSendFailureZ* arg_conv = (LDKCResult_PaymentIdPaymentSendFailureZ*)(arg & ~1);
+ int64_t ret_val = CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentSendFailureZ_clone(uint32_t orig) {
LDKCResult_PaymentIdPaymentSendFailureZ* orig_conv = (LDKCResult_PaymentIdPaymentSendFailureZ*)(orig & ~1);
LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_is_ok(uint32_t o) {
+ LDKCResult_NonePaymentSendFailureZ* o_conv = (LDKCResult_NonePaymentSendFailureZ*)(o & ~1);
+ jboolean ret_val = CResult_NonePaymentSendFailureZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NonePaymentSendFailureZ_free(_res_conv);
}
+static inline uint64_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg) {
+ LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
+ *ret_conv = CResult_NonePaymentSendFailureZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NonePaymentSendFailureZ* arg_conv = (LDKCResult_NonePaymentSendFailureZ*)(arg & ~1);
+ int64_t ret_val = CResult_NonePaymentSendFailureZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_clone(uint32_t orig) {
LDKCResult_NonePaymentSendFailureZ* orig_conv = (LDKCResult_NonePaymentSendFailureZ*)(orig & ~1);
LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg) {
+ LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
+ *ret_conv = C2Tuple_PaymentHashPaymentIdZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_PaymentHashPaymentIdZ* arg_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentIdZ_clone(uint32_t orig) {
LDKC2Tuple_PaymentHashPaymentIdZ* orig_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)(orig & ~1);
LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(uint32_t o) {
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* o_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(o & ~1);
+ jboolean ret_val = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res_conv);
}
+static inline uint64_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg) {
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
+ *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(uint32_t arg) {
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* arg_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(arg & ~1);
+ int64_t ret_val = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(uint32_t orig) {
LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* orig_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(orig & ~1);
LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
CVec_NetAddressZ_free(_res_constr);
}
+static inline uint64_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg) {
+ LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
+ *ret_conv = C2Tuple_PaymentHashPaymentSecretZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_PaymentHashPaymentSecretZ* arg_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentSecretZ_clone(uint32_t orig) {
LDKC2Tuple_PaymentHashPaymentSecretZ* orig_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(orig & ~1);
LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_PaymentSecretAPIErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PaymentSecretAPIErrorZ* o_conv = (LDKCResult_PaymentSecretAPIErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PaymentSecretAPIErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_PaymentSecretAPIErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PaymentSecretAPIErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
+ *ret_conv = CResult_PaymentSecretAPIErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PaymentSecretAPIErrorZ* arg_conv = (LDKCResult_PaymentSecretAPIErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PaymentSecretAPIErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentSecretAPIErrorZ_clone(uint32_t orig) {
LDKCResult_PaymentSecretAPIErrorZ* orig_conv = (LDKCResult_PaymentSecretAPIErrorZ*)(orig & ~1);
LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
LDKChannelMonitor _res_conv_16_conv;
_res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
_res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
_res_constr.data[q] = _res_conv_16_conv;
}
CVec_ChannelMonitorZ_free(_res_constr);
LDKChannelManager b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = (b & 1) || (b == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
// Warning: we need a move here but no clone is available for LDKChannelManager
LDKC2Tuple_BlockHashChannelManagerZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelManagerZ), "LDKC2Tuple_BlockHashChannelManagerZ");
*ret_conv = C2Tuple_BlockHashChannelManagerZ_new(a_ref, b_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
*ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* o_conv = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKChannelConfig o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelConfig_clone(&o_conv);
LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
*ret_conv = CResult_ChannelConfigDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
*ret_conv = CResult_ChannelConfigDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelConfigDecodeErrorZ* o_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelConfigDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelConfigDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
+ *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ChannelConfigDecodeErrorZ* arg_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ChannelConfigDecodeErrorZ* orig_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
LDKOutPoint o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = OutPoint_clone(&o_conv);
LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
*ret_conv = CResult_OutPointDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
*ret_conv = CResult_OutPointDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_OutPointDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_OutPointDecodeErrorZ* o_conv = (LDKCResult_OutPointDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_OutPointDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_OutPointDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_OutPointDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
+ *ret_conv = CResult_OutPointDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_OutPointDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_OutPointDecodeErrorZ* arg_conv = (LDKCResult_OutPointDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_OutPointDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_OutPointDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_OutPointDecodeErrorZ* orig_conv = (LDKCResult_OutPointDecodeErrorZ*)(orig & ~1);
LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
COption_TypeZ_free(_res_conv);
}
+static inline uint64_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg) {
+ LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
+ *ret_copy = COption_TypeZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_TypeZ_clone_ptr(uint32_t arg) {
+ LDKCOption_TypeZ* arg_conv = (LDKCOption_TypeZ*)arg;
+ int64_t ret_val = COption_TypeZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_COption_TypeZ_clone(uint32_t orig) {
LDKCOption_TypeZ* orig_conv = (LDKCOption_TypeZ*)orig;
LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
*ret_conv = CResult_COption_TypeZDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_COption_TypeZDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_COption_TypeZDecodeErrorZ* o_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_TypeZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_COption_TypeZDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_COption_TypeZDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
+ *ret_conv = CResult_COption_TypeZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_COption_TypeZDecodeErrorZ* arg_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_COption_TypeZDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_COption_TypeZDecodeErrorZ* orig_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)(orig & ~1);
LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PaymentIdPaymentErrorZ* o_conv = (LDKCResult_PaymentIdPaymentErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PaymentIdPaymentErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PaymentIdPaymentErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
+ *ret_conv = CResult_PaymentIdPaymentErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PaymentIdPaymentErrorZ* arg_conv = (LDKCResult_PaymentIdPaymentErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PaymentIdPaymentErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentErrorZ_clone(uint32_t orig) {
LDKCResult_PaymentIdPaymentErrorZ* orig_conv = (LDKCResult_PaymentIdPaymentErrorZ*)(orig & ~1);
LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_SiPrefixNoneZ_is_ok(uint32_t o) {
+ LDKCResult_SiPrefixNoneZ* o_conv = (LDKCResult_SiPrefixNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_SiPrefixNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_SiPrefixNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_SiPrefixNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_SiPrefixNoneZ_clone_ptr(LDKCResult_SiPrefixNoneZ *NONNULL_PTR arg) {
+ LDKCResult_SiPrefixNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixNoneZ), "LDKCResult_SiPrefixNoneZ");
+ *ret_conv = CResult_SiPrefixNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_SiPrefixNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_SiPrefixNoneZ* arg_conv = (LDKCResult_SiPrefixNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_SiPrefixNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_SiPrefixNoneZ_clone(uint32_t orig) {
LDKCResult_SiPrefixNoneZ* orig_conv = (LDKCResult_SiPrefixNoneZ*)(orig & ~1);
LDKCResult_SiPrefixNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixNoneZ), "LDKCResult_SiPrefixNoneZ");
LDKInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Invoice_clone(&o_conv);
LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
*ret_conv = CResult_InvoiceNoneZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_InvoiceNoneZ_is_ok(uint32_t o) {
+ LDKCResult_InvoiceNoneZ* o_conv = (LDKCResult_InvoiceNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_InvoiceNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_InvoiceNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_InvoiceNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_InvoiceNoneZ_clone_ptr(LDKCResult_InvoiceNoneZ *NONNULL_PTR arg) {
+ LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
+ *ret_conv = CResult_InvoiceNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_InvoiceNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_InvoiceNoneZ* arg_conv = (LDKCResult_InvoiceNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_InvoiceNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceNoneZ_clone(uint32_t orig) {
LDKCResult_InvoiceNoneZ* orig_conv = (LDKCResult_InvoiceNoneZ*)(orig & ~1);
LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
LDKSignedRawInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = SignedRawInvoice_clone(&o_conv);
LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
*ret_conv = CResult_SignedRawInvoiceNoneZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_SignedRawInvoiceNoneZ_is_ok(uint32_t o) {
+ LDKCResult_SignedRawInvoiceNoneZ* o_conv = (LDKCResult_SignedRawInvoiceNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_SignedRawInvoiceNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_SignedRawInvoiceNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_SignedRawInvoiceNoneZ_free(_res_conv);
}
+static inline uint64_t CResult_SignedRawInvoiceNoneZ_clone_ptr(LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR arg) {
+ LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
+ *ret_conv = CResult_SignedRawInvoiceNoneZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_SignedRawInvoiceNoneZ_clone_ptr(uint32_t arg) {
+ LDKCResult_SignedRawInvoiceNoneZ* arg_conv = (LDKCResult_SignedRawInvoiceNoneZ*)(arg & ~1);
+ int64_t ret_val = CResult_SignedRawInvoiceNoneZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_SignedRawInvoiceNoneZ_clone(uint32_t orig) {
LDKCResult_SignedRawInvoiceNoneZ* orig_conv = (LDKCResult_SignedRawInvoiceNoneZ*)(orig & ~1);
LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg) {
+ LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
+ *ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(uint32_t arg) {
+ LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* arg_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(arg & ~1);
+ int64_t ret_val = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(uint32_t orig) {
LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* orig_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(orig & ~1);
LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
LDKRawInvoice a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = RawInvoice_clone(&a_conv);
LDKThirtyTwoBytes b_ref;
CHECK(*((uint32_t*)b) == 32);
LDKInvoiceSignature c_conv;
c_conv.inner = (void*)(c & (~1));
c_conv.is_owned = (c & 1) || (c == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(c_conv);
c_conv = InvoiceSignature_clone(&c_conv);
LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
*ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a_conv, b_ref, c_conv);
LDKPayeePubKey o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = PayeePubKey_clone(&o_conv);
LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
*ret_conv = CResult_PayeePubKeyErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_PayeePubKeyErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PayeePubKeyErrorZ* o_conv = (LDKCResult_PayeePubKeyErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PayeePubKeyErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_PayeePubKeyErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PayeePubKeyErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
+ *ret_conv = CResult_PayeePubKeyErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PayeePubKeyErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PayeePubKeyErrorZ* arg_conv = (LDKCResult_PayeePubKeyErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PayeePubKeyErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_PayeePubKeyErrorZ_clone(uint32_t orig) {
LDKCResult_PayeePubKeyErrorZ* orig_conv = (LDKCResult_PayeePubKeyErrorZ*)(orig & ~1);
LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
LDKPrivateRoute _res_conv_14_conv;
_res_conv_14_conv.inner = (void*)(_res_conv_14 & (~1));
_res_conv_14_conv.is_owned = (_res_conv_14 & 1) || (_res_conv_14 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_14_conv);
_res_constr.data[o] = _res_conv_14_conv;
}
CVec_PrivateRouteZ_free(_res_constr);
LDKPositiveTimestamp o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = PositiveTimestamp_clone(&o_conv);
LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
*ret_conv = CResult_PositiveTimestampCreationErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_PositiveTimestampCreationErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PositiveTimestampCreationErrorZ* o_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PositiveTimestampCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_PositiveTimestampCreationErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PositiveTimestampCreationErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
+ *ret_conv = CResult_PositiveTimestampCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PositiveTimestampCreationErrorZ* arg_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_PositiveTimestampCreationErrorZ_clone(uint32_t orig) {
LDKCResult_PositiveTimestampCreationErrorZ* orig_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)(orig & ~1);
LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NoneSemanticErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NoneSemanticErrorZ* o_conv = (LDKCResult_NoneSemanticErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneSemanticErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NoneSemanticErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneSemanticErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
+ *ret_conv = CResult_NoneSemanticErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NoneSemanticErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NoneSemanticErrorZ* arg_conv = (LDKCResult_NoneSemanticErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneSemanticErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NoneSemanticErrorZ_clone(uint32_t orig) {
LDKCResult_NoneSemanticErrorZ* orig_conv = (LDKCResult_NoneSemanticErrorZ*)(orig & ~1);
LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
LDKInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Invoice_clone(&o_conv);
LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
*ret_conv = CResult_InvoiceSemanticErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_InvoiceSemanticErrorZ_is_ok(uint32_t o) {
+ LDKCResult_InvoiceSemanticErrorZ* o_conv = (LDKCResult_InvoiceSemanticErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InvoiceSemanticErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_InvoiceSemanticErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_InvoiceSemanticErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg) {
+ LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
+ *ret_conv = CResult_InvoiceSemanticErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_InvoiceSemanticErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_InvoiceSemanticErrorZ* arg_conv = (LDKCResult_InvoiceSemanticErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_InvoiceSemanticErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceSemanticErrorZ_clone(uint32_t orig) {
LDKCResult_InvoiceSemanticErrorZ* orig_conv = (LDKCResult_InvoiceSemanticErrorZ*)(orig & ~1);
LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
LDKDescription o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Description_clone(&o_conv);
LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
*ret_conv = CResult_DescriptionCreationErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_DescriptionCreationErrorZ_is_ok(uint32_t o) {
+ LDKCResult_DescriptionCreationErrorZ* o_conv = (LDKCResult_DescriptionCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_DescriptionCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_DescriptionCreationErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_DescriptionCreationErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
+ *ret_conv = CResult_DescriptionCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_DescriptionCreationErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_DescriptionCreationErrorZ* arg_conv = (LDKCResult_DescriptionCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_DescriptionCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_DescriptionCreationErrorZ_clone(uint32_t orig) {
LDKCResult_DescriptionCreationErrorZ* orig_conv = (LDKCResult_DescriptionCreationErrorZ*)(orig & ~1);
LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
LDKExpiryTime o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ExpiryTime_clone(&o_conv);
LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
*ret_conv = CResult_ExpiryTimeCreationErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ExpiryTimeCreationErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ExpiryTimeCreationErrorZ* o_conv = (LDKCResult_ExpiryTimeCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ExpiryTimeCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ExpiryTimeCreationErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ExpiryTimeCreationErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ExpiryTimeCreationErrorZ_clone_ptr(LDKCResult_ExpiryTimeCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
+ *ret_conv = CResult_ExpiryTimeCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ExpiryTimeCreationErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ExpiryTimeCreationErrorZ* arg_conv = (LDKCResult_ExpiryTimeCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ExpiryTimeCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ExpiryTimeCreationErrorZ_clone(uint32_t orig) {
LDKCResult_ExpiryTimeCreationErrorZ* orig_conv = (LDKCResult_ExpiryTimeCreationErrorZ*)(orig & ~1);
LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
LDKPrivateRoute o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = PrivateRoute_clone(&o_conv);
LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
*ret_conv = CResult_PrivateRouteCreationErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_PrivateRouteCreationErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PrivateRouteCreationErrorZ* o_conv = (LDKCResult_PrivateRouteCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PrivateRouteCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_PrivateRouteCreationErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PrivateRouteCreationErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
+ *ret_conv = CResult_PrivateRouteCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PrivateRouteCreationErrorZ* arg_conv = (LDKCResult_PrivateRouteCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PrivateRouteCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_PrivateRouteCreationErrorZ_clone(uint32_t orig) {
LDKCResult_PrivateRouteCreationErrorZ* orig_conv = (LDKCResult_PrivateRouteCreationErrorZ*)(orig & ~1);
LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_StringErrorZ_is_ok(uint32_t o) {
+ LDKCResult_StringErrorZ* o_conv = (LDKCResult_StringErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_StringErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_StringErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKChannelMonitorUpdate o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelMonitorUpdate_clone(&o_conv);
LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
*ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
*ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* o_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
+ *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* arg_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ChannelMonitorUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
return (uint64_t)ret_conv;
}
+uint32_t __attribute__((visibility("default"))) TS_COption_MonitorEventZ_some(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKMonitorEvent o_conv = *(LDKMonitorEvent*)(o_ptr);
+ o_conv = MonitorEvent_clone((LDKMonitorEvent*)(((uint64_t)o) & ~1));
+ LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
+ *ret_copy = COption_MonitorEventZ_some(o_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_MonitorEventZ_none() {
+ LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
+ *ret_copy = COption_MonitorEventZ_none();
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_COption_MonitorEventZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCOption_MonitorEventZ _res_conv = *(LDKCOption_MonitorEventZ*)(_res_ptr);
+ FREE((void*)_res);
+ COption_MonitorEventZ_free(_res_conv);
+}
+
+static inline uint64_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg) {
+ LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
+ *ret_copy = COption_MonitorEventZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_MonitorEventZ_clone_ptr(uint32_t arg) {
+ LDKCOption_MonitorEventZ* arg_conv = (LDKCOption_MonitorEventZ*)arg;
+ int64_t ret_val = COption_MonitorEventZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_COption_MonitorEventZ_clone(uint32_t orig) {
+ LDKCOption_MonitorEventZ* orig_conv = (LDKCOption_MonitorEventZ*)orig;
+ LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
+ *ret_copy = COption_MonitorEventZ_clone(orig_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKCOption_MonitorEventZ o_conv = *(LDKCOption_MonitorEventZ*)(o_ptr);
+ o_conv = COption_MonitorEventZ_clone((LDKCOption_MonitorEventZ*)(((uint64_t)o) & ~1));
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* o_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_COption_MonitorEventZDecodeErrorZ _res_conv = *(LDKCResult_COption_MonitorEventZDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_COption_MonitorEventZDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* arg_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* orig_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(orig & ~1);
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_HTLCUpdateDecodeErrorZ_ok(uint32_t o) {
LDKHTLCUpdate o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = HTLCUpdate_clone(&o_conv);
LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
*ret_conv = CResult_HTLCUpdateDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
*ret_conv = CResult_HTLCUpdateDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_HTLCUpdateDecodeErrorZ* o_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_HTLCUpdateDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_HTLCUpdateDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_HTLCUpdateDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
+ *ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_HTLCUpdateDecodeErrorZ* arg_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_HTLCUpdateDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_HTLCUpdateDecodeErrorZ* orig_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(orig & ~1);
LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
LDKMonitorUpdateError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = MonitorUpdateError_clone(&e_conv);
LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
*ret_conv = CResult_NoneMonitorUpdateErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NoneMonitorUpdateErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NoneMonitorUpdateErrorZ* o_conv = (LDKCResult_NoneMonitorUpdateErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneMonitorUpdateErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NoneMonitorUpdateErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneMonitorUpdateErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneMonitorUpdateErrorZ_clone_ptr(LDKCResult_NoneMonitorUpdateErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
+ *ret_conv = CResult_NoneMonitorUpdateErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NoneMonitorUpdateErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NoneMonitorUpdateErrorZ* arg_conv = (LDKCResult_NoneMonitorUpdateErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneMonitorUpdateErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NoneMonitorUpdateErrorZ_clone(uint32_t orig) {
LDKCResult_NoneMonitorUpdateErrorZ* orig_conv = (LDKCResult_NoneMonitorUpdateErrorZ*)(orig & ~1);
LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg) {
+ LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
+ *ret_conv = C2Tuple_OutPointScriptZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_OutPointScriptZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_OutPointScriptZ* arg_conv = (LDKC2Tuple_OutPointScriptZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_OutPointScriptZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C2Tuple_OutPointScriptZ_clone(uint32_t orig) {
LDKC2Tuple_OutPointScriptZ* orig_conv = (LDKC2Tuple_OutPointScriptZ*)(orig & ~1);
LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
LDKOutPoint a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = OutPoint_clone(&a_conv);
LDKCVec_u8Z b_ref;
b_ref.datalen = *((uint32_t*)b);
C2Tuple_OutPointScriptZ_free(_res_conv);
}
+static inline uint64_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg) {
+ LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
+ *ret_conv = C2Tuple_u32ScriptZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_u32ScriptZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_u32ScriptZ* arg_conv = (LDKC2Tuple_u32ScriptZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_u32ScriptZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C2Tuple_u32ScriptZ_clone(uint32_t orig) {
LDKC2Tuple_u32ScriptZ* orig_conv = (LDKC2Tuple_u32ScriptZ*)(orig & ~1);
LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
CVec_C2Tuple_u32ScriptZZ_free(_res_constr);
}
+static inline uint64_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg) {
+ LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
+ *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* arg_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(uint32_t orig) {
LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(orig & ~1);
LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
CVec_TransactionZ_free(_res_constr);
}
+static inline uint64_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg) {
+ LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
+ *ret_conv = C2Tuple_u32TxOutZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_u32TxOutZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_u32TxOutZ* arg_conv = (LDKC2Tuple_u32TxOutZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_u32TxOutZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C2Tuple_u32TxOutZ_clone(uint32_t orig) {
LDKC2Tuple_u32TxOutZ* orig_conv = (LDKC2Tuple_u32TxOutZ*)(orig & ~1);
LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
CVec_C2Tuple_u32TxOutZZ_free(_res_constr);
}
+static inline uint64_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg) {
+ LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
+ *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* arg_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(uint32_t orig) {
LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(orig & ~1);
LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
*ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* o_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
+ *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* arg_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* orig_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(orig & ~1);
LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
LDKLightningError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = LightningError_clone(&e_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = CResult_NoneLightningErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NoneLightningErrorZ* o_conv = (LDKCResult_NoneLightningErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NoneLightningErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NoneLightningErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
+ *ret_conv = CResult_NoneLightningErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NoneLightningErrorZ* arg_conv = (LDKCResult_NoneLightningErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NoneLightningErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_clone(uint32_t orig) {
LDKCResult_NoneLightningErrorZ* orig_conv = (LDKCResult_NoneLightningErrorZ*)(orig & ~1);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg) {
+ LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
+ *ret_conv = C2Tuple_PublicKeyTypeZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C2Tuple_PublicKeyTypeZ_clone_ptr(uint32_t arg) {
+ LDKC2Tuple_PublicKeyTypeZ* arg_conv = (LDKC2Tuple_PublicKeyTypeZ*)(arg & ~1);
+ int64_t ret_val = C2Tuple_PublicKeyTypeZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PublicKeyTypeZ_clone(uint32_t orig) {
LDKC2Tuple_PublicKeyTypeZ* orig_conv = (LDKC2Tuple_PublicKeyTypeZ*)(orig & ~1);
LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
LDKLightningError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = LightningError_clone(&e_conv);
LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
*ret_conv = CResult_boolLightningErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_is_ok(uint32_t o) {
+ LDKCResult_boolLightningErrorZ* o_conv = (LDKCResult_boolLightningErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_boolLightningErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_boolLightningErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg) {
+ LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
+ *ret_conv = CResult_boolLightningErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_boolLightningErrorZ* arg_conv = (LDKCResult_boolLightningErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_boolLightningErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_clone(uint32_t orig) {
LDKCResult_boolLightningErrorZ* orig_conv = (LDKCResult_boolLightningErrorZ*)(orig & ~1);
LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
return (uint64_t)ret_conv;
}
+static inline uint64_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg) {
+ LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
+ *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(arg);
+ return ((uint64_t)ret_conv);
+}
+int64_t __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(uint32_t arg) {
+ LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* arg_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(arg & ~1);
+ int64_t ret_val = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(uint32_t orig) {
LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* orig_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(orig & ~1);
LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
LDKChannelAnnouncement a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = ChannelAnnouncement_clone(&a_conv);
LDKChannelUpdate b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = (b & 1) || (b == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
b_conv = ChannelUpdate_clone(&b_conv);
LDKChannelUpdate c_conv;
c_conv.inner = (void*)(c & (~1));
c_conv.is_owned = (c & 1) || (c == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(c_conv);
c_conv = ChannelUpdate_clone(&c_conv);
LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
*ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a_conv, b_conv, c_conv);
LDKNodeAnnouncement _res_conv_18_conv;
_res_conv_18_conv.inner = (void*)(_res_conv_18 & (~1));
_res_conv_18_conv.is_owned = (_res_conv_18 & 1) || (_res_conv_18 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_18_conv);
_res_constr.data[s] = _res_conv_18_conv;
}
CVec_NodeAnnouncementZ_free(_res_constr);
LDKPeerHandleError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = PeerHandleError_clone(&e_conv);
LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
*ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(uint32_t o) {
+ LDKCResult_CVec_u8ZPeerHandleErrorZ* o_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CVec_u8ZPeerHandleErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
+ *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_CVec_u8ZPeerHandleErrorZ* arg_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(uint32_t orig) {
LDKCResult_CVec_u8ZPeerHandleErrorZ* orig_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(orig & ~1);
LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
LDKPeerHandleError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = PeerHandleError_clone(&e_conv);
LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
*ret_conv = CResult_NonePeerHandleErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NonePeerHandleErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NonePeerHandleErrorZ* o_conv = (LDKCResult_NonePeerHandleErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NonePeerHandleErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NonePeerHandleErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NonePeerHandleErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
+ *ret_conv = CResult_NonePeerHandleErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NonePeerHandleErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NonePeerHandleErrorZ* arg_conv = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NonePeerHandleErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NonePeerHandleErrorZ_clone(uint32_t orig) {
LDKCResult_NonePeerHandleErrorZ* orig_conv = (LDKCResult_NonePeerHandleErrorZ*)(orig & ~1);
LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
LDKPeerHandleError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = PeerHandleError_clone(&e_conv);
LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
*ret_conv = CResult_boolPeerHandleErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_boolPeerHandleErrorZ_is_ok(uint32_t o) {
+ LDKCResult_boolPeerHandleErrorZ* o_conv = (LDKCResult_boolPeerHandleErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_boolPeerHandleErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_boolPeerHandleErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_boolPeerHandleErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg) {
+ LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
+ *ret_conv = CResult_boolPeerHandleErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_boolPeerHandleErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_boolPeerHandleErrorZ* arg_conv = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_boolPeerHandleErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_boolPeerHandleErrorZ_clone(uint32_t orig) {
LDKCResult_boolPeerHandleErrorZ* orig_conv = (LDKCResult_boolPeerHandleErrorZ*)(orig & ~1);
LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
LDKNodeId o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NodeId_clone(&o_conv);
LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
*ret_conv = CResult_NodeIdDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
+ e_conv = DecodeError_clone(&e_conv);
+ LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
+ *ret_conv = CResult_NodeIdDecodeErrorZ_err(e_conv);
+ return (uint64_t)ret_conv;
+}
+
+jboolean __attribute__((visibility("default"))) TS_CResult_NodeIdDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NodeIdDecodeErrorZ* o_conv = (LDKCResult_NodeIdDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeIdDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_NodeIdDecodeErrorZ_free(uint32_t _res) {
+ if ((_res & 1) != 0) return;
+ void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
+ CHECK_ACCESS(_res_ptr);
+ LDKCResult_NodeIdDecodeErrorZ _res_conv = *(LDKCResult_NodeIdDecodeErrorZ*)(_res_ptr);
+ FREE((void*)_res);
+ CResult_NodeIdDecodeErrorZ_free(_res_conv);
+}
+
+static inline uint64_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
+ *ret_conv = CResult_NodeIdDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NodeIdDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NodeIdDecodeErrorZ* arg_conv = (LDKCResult_NodeIdDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NodeIdDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_NodeIdDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_NodeIdDecodeErrorZ* orig_conv = (LDKCResult_NodeIdDecodeErrorZ*)(orig & ~1);
+ LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
+ *ret_conv = CResult_NodeIdDecodeErrorZ_clone(orig_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(uint32_t o) {
+ void* o_ptr = (void*)(((uint64_t)o) & ~1);
+ CHECK_ACCESS(o_ptr);
+ LDKCOption_NetworkUpdateZ o_conv = *(LDKCOption_NetworkUpdateZ*)(o_ptr);
+ o_conv = COption_NetworkUpdateZ_clone((LDKCOption_NetworkUpdateZ*)(((uint64_t)o) & ~1));
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o_conv);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(uint32_t e) {
+ LDKDecodeError e_conv;
+ e_conv.inner = (void*)(e & (~1));
+ e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
- LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
- *ret_conv = CResult_NodeIdDecodeErrorZ_err(e_conv);
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
-void __attribute__((visibility("default"))) TS_CResult_NodeIdDecodeErrorZ_free(uint32_t _res) {
+jboolean __attribute__((visibility("default"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* o_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CHECK_ACCESS(_res_ptr);
- LDKCResult_NodeIdDecodeErrorZ _res_conv = *(LDKCResult_NodeIdDecodeErrorZ*)(_res_ptr);
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res_conv = *(LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(_res_ptr);
FREE((void*)_res);
- CResult_NodeIdDecodeErrorZ_free(_res_conv);
+ CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res_conv);
}
-uint32_t __attribute__((visibility("default"))) TS_CResult_NodeIdDecodeErrorZ_clone(uint32_t orig) {
- LDKCResult_NodeIdDecodeErrorZ* orig_conv = (LDKCResult_NodeIdDecodeErrorZ*)(orig & ~1);
- LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
- *ret_conv = CResult_NodeIdDecodeErrorZ_clone(orig_conv);
+static inline uint64_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* arg_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(uint32_t orig) {
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* orig_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(orig & ~1);
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig_conv);
return (uint64_t)ret_conv;
}
LDKDirectionalChannelInfo o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = DirectionalChannelInfo_clone(&o_conv);
LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
*ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
*ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_DirectionalChannelInfoDecodeErrorZ* o_conv = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_DirectionalChannelInfoDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_DirectionalChannelInfoDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
+ *ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_DirectionalChannelInfoDecodeErrorZ* arg_conv = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_DirectionalChannelInfoDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_DirectionalChannelInfoDecodeErrorZ* orig_conv = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(orig & ~1);
LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
LDKChannelInfo o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelInfo_clone(&o_conv);
LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
*ret_conv = CResult_ChannelInfoDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
*ret_conv = CResult_ChannelInfoDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelInfoDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelInfoDecodeErrorZ* o_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelInfoDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ChannelInfoDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelInfoDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
+ *ret_conv = CResult_ChannelInfoDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ChannelInfoDecodeErrorZ* arg_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelInfoDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ChannelInfoDecodeErrorZ* orig_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
LDKRoutingFees o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RoutingFees_clone(&o_conv);
LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
*ret_conv = CResult_RoutingFeesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
*ret_conv = CResult_RoutingFeesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_RoutingFeesDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_RoutingFeesDecodeErrorZ* o_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RoutingFeesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_RoutingFeesDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RoutingFeesDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
+ *ret_conv = CResult_RoutingFeesDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_RoutingFeesDecodeErrorZ* arg_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_RoutingFeesDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_RoutingFeesDecodeErrorZ* orig_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(orig & ~1);
LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
LDKNodeAnnouncementInfo o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NodeAnnouncementInfo_clone(&o_conv);
LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
*ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
*ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ* o_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
+ *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ* arg_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_NodeAnnouncementInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(orig & ~1);
LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
LDKNodeInfo o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NodeInfo_clone(&o_conv);
LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
*ret_conv = CResult_NodeInfoDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
*ret_conv = CResult_NodeInfoDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NodeInfoDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NodeInfoDecodeErrorZ* o_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeInfoDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NodeInfoDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NodeInfoDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
+ *ret_conv = CResult_NodeInfoDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NodeInfoDecodeErrorZ* arg_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NodeInfoDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NodeInfoDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_NodeInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(orig & ~1);
LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
LDKNetworkGraph o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NetworkGraph_clone(&o_conv);
LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
*ret_conv = CResult_NetworkGraphDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
*ret_conv = CResult_NetworkGraphDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NetworkGraphDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NetworkGraphDecodeErrorZ* o_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NetworkGraphDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NetworkGraphDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NetworkGraphDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NetworkGraphDecodeErrorZ_clone_ptr(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
+ *ret_conv = CResult_NetworkGraphDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NetworkGraphDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NetworkGraphDecodeErrorZ* arg_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NetworkGraphDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NetworkGraphDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_NetworkGraphDecodeErrorZ* orig_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)(orig & ~1);
LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
COption_CVec_NetAddressZZ_free(_res_conv);
}
+static inline uint64_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg) {
+ LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
+ *ret_copy = COption_CVec_NetAddressZZ_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_COption_CVec_NetAddressZZ_clone_ptr(uint32_t arg) {
+ LDKCOption_CVec_NetAddressZZ* arg_conv = (LDKCOption_CVec_NetAddressZZ*)arg;
+ int64_t ret_val = COption_CVec_NetAddressZZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_COption_CVec_NetAddressZZ_clone(uint32_t orig) {
LDKCOption_CVec_NetAddressZZ* orig_conv = (LDKCOption_CVec_NetAddressZZ*)orig;
LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
*ret_conv = CResult_NetAddressDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NetAddressDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NetAddressDecodeErrorZ* o_conv = (LDKCResult_NetAddressDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NetAddressDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NetAddressDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NetAddressDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
+ *ret_conv = CResult_NetAddressDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NetAddressDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NetAddressDecodeErrorZ* arg_conv = (LDKCResult_NetAddressDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NetAddressDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NetAddressDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_NetAddressDecodeErrorZ* orig_conv = (LDKCResult_NetAddressDecodeErrorZ*)(orig & ~1);
LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
LDKUpdateAddHTLC _res_conv_15_conv;
_res_conv_15_conv.inner = (void*)(_res_conv_15 & (~1));
_res_conv_15_conv.is_owned = (_res_conv_15 & 1) || (_res_conv_15 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_15_conv);
_res_constr.data[p] = _res_conv_15_conv;
}
CVec_UpdateAddHTLCZ_free(_res_constr);
LDKUpdateFulfillHTLC _res_conv_19_conv;
_res_conv_19_conv.inner = (void*)(_res_conv_19 & (~1));
_res_conv_19_conv.is_owned = (_res_conv_19 & 1) || (_res_conv_19 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_19_conv);
_res_constr.data[t] = _res_conv_19_conv;
}
CVec_UpdateFulfillHTLCZ_free(_res_constr);
LDKUpdateFailHTLC _res_conv_16_conv;
_res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
_res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
_res_constr.data[q] = _res_conv_16_conv;
}
CVec_UpdateFailHTLCZ_free(_res_constr);
LDKUpdateFailMalformedHTLC _res_conv_25_conv;
_res_conv_25_conv.inner = (void*)(_res_conv_25 & (~1));
_res_conv_25_conv.is_owned = (_res_conv_25 & 1) || (_res_conv_25 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_25_conv);
_res_constr.data[z] = _res_conv_25_conv;
}
CVec_UpdateFailMalformedHTLCZ_free(_res_constr);
LDKAcceptChannel o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = AcceptChannel_clone(&o_conv);
LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
*ret_conv = CResult_AcceptChannelDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
*ret_conv = CResult_AcceptChannelDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_AcceptChannelDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_AcceptChannelDecodeErrorZ* o_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_AcceptChannelDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_AcceptChannelDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_AcceptChannelDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
+ *ret_conv = CResult_AcceptChannelDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_AcceptChannelDecodeErrorZ* arg_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_AcceptChannelDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_AcceptChannelDecodeErrorZ* orig_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(orig & ~1);
LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
LDKAnnouncementSignatures o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = AnnouncementSignatures_clone(&o_conv);
LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
*ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
*ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ* o_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_AnnouncementSignaturesDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
+ *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ* arg_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_AnnouncementSignaturesDecodeErrorZ* orig_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(orig & ~1);
LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
LDKChannelReestablish o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelReestablish_clone(&o_conv);
LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
*ret_conv = CResult_ChannelReestablishDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
*ret_conv = CResult_ChannelReestablishDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelReestablishDecodeErrorZ* o_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelReestablishDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ChannelReestablishDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelReestablishDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
+ *ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ChannelReestablishDecodeErrorZ* arg_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelReestablishDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ChannelReestablishDecodeErrorZ* orig_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
LDKClosingSigned o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ClosingSigned_clone(&o_conv);
LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
*ret_conv = CResult_ClosingSignedDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
*ret_conv = CResult_ClosingSignedDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ClosingSignedDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ClosingSignedDecodeErrorZ* o_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ClosingSignedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ClosingSignedDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ClosingSignedDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
+ *ret_conv = CResult_ClosingSignedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ClosingSignedDecodeErrorZ* arg_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ClosingSignedDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ClosingSignedDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(orig & ~1);
LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
LDKClosingSignedFeeRange o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ClosingSignedFeeRange_clone(&o_conv);
LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
*ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
*ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* o_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
+ *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* arg_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(orig & ~1);
LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
LDKCommitmentSigned o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = CommitmentSigned_clone(&o_conv);
LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
*ret_conv = CResult_CommitmentSignedDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
*ret_conv = CResult_CommitmentSignedDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_CommitmentSignedDecodeErrorZ* o_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_CommitmentSignedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_CommitmentSignedDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_CommitmentSignedDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
+ *ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_CommitmentSignedDecodeErrorZ* arg_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_CommitmentSignedDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_CommitmentSignedDecodeErrorZ* orig_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(orig & ~1);
LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
LDKFundingCreated o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = FundingCreated_clone(&o_conv);
LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
*ret_conv = CResult_FundingCreatedDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
*ret_conv = CResult_FundingCreatedDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_FundingCreatedDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_FundingCreatedDecodeErrorZ* o_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_FundingCreatedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_FundingCreatedDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_FundingCreatedDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
+ *ret_conv = CResult_FundingCreatedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_FundingCreatedDecodeErrorZ* arg_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_FundingCreatedDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_FundingCreatedDecodeErrorZ* orig_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(orig & ~1);
LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
LDKFundingSigned o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = FundingSigned_clone(&o_conv);
LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
*ret_conv = CResult_FundingSignedDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
*ret_conv = CResult_FundingSignedDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_FundingSignedDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_FundingSignedDecodeErrorZ* o_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_FundingSignedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_FundingSignedDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_FundingSignedDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
+ *ret_conv = CResult_FundingSignedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_FundingSignedDecodeErrorZ* arg_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_FundingSignedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_FundingSignedDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_FundingSignedDecodeErrorZ* orig_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(orig & ~1);
LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
LDKFundingLocked o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = FundingLocked_clone(&o_conv);
LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
*ret_conv = CResult_FundingLockedDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
*ret_conv = CResult_FundingLockedDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_FundingLockedDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_FundingLockedDecodeErrorZ* o_conv = (LDKCResult_FundingLockedDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_FundingLockedDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_FundingLockedDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_FundingLockedDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_FundingLockedDecodeErrorZ_clone_ptr(LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
+ *ret_conv = CResult_FundingLockedDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_FundingLockedDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_FundingLockedDecodeErrorZ* arg_conv = (LDKCResult_FundingLockedDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_FundingLockedDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_FundingLockedDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_FundingLockedDecodeErrorZ* orig_conv = (LDKCResult_FundingLockedDecodeErrorZ*)(orig & ~1);
LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
LDKInit o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Init_clone(&o_conv);
LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
*ret_conv = CResult_InitDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
*ret_conv = CResult_InitDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_InitDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_InitDecodeErrorZ* o_conv = (LDKCResult_InitDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InitDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_InitDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_InitDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
+ *ret_conv = CResult_InitDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_InitDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_InitDecodeErrorZ* arg_conv = (LDKCResult_InitDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_InitDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_InitDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_InitDecodeErrorZ* orig_conv = (LDKCResult_InitDecodeErrorZ*)(orig & ~1);
LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
LDKOpenChannel o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = OpenChannel_clone(&o_conv);
LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
*ret_conv = CResult_OpenChannelDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
*ret_conv = CResult_OpenChannelDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_OpenChannelDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_OpenChannelDecodeErrorZ* o_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_OpenChannelDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_OpenChannelDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_OpenChannelDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
+ *ret_conv = CResult_OpenChannelDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_OpenChannelDecodeErrorZ* arg_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_OpenChannelDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_OpenChannelDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_OpenChannelDecodeErrorZ* orig_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(orig & ~1);
LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
LDKRevokeAndACK o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = RevokeAndACK_clone(&o_conv);
LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
*ret_conv = CResult_RevokeAndACKDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
*ret_conv = CResult_RevokeAndACKDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_RevokeAndACKDecodeErrorZ* o_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_RevokeAndACKDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_RevokeAndACKDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_RevokeAndACKDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
+ *ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_RevokeAndACKDecodeErrorZ* arg_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_RevokeAndACKDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_RevokeAndACKDecodeErrorZ* orig_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(orig & ~1);
LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
LDKShutdown o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Shutdown_clone(&o_conv);
LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
*ret_conv = CResult_ShutdownDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
*ret_conv = CResult_ShutdownDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ShutdownDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ShutdownDecodeErrorZ* o_conv = (LDKCResult_ShutdownDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ShutdownDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ShutdownDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ShutdownDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
+ *ret_conv = CResult_ShutdownDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ShutdownDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ShutdownDecodeErrorZ* arg_conv = (LDKCResult_ShutdownDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ShutdownDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ShutdownDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ShutdownDecodeErrorZ* orig_conv = (LDKCResult_ShutdownDecodeErrorZ*)(orig & ~1);
LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
LDKUpdateFailHTLC o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UpdateFailHTLC_clone(&o_conv);
LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UpdateFailHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UpdateFailHTLCDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UpdateFailHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_UpdateFailHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(orig & ~1);
LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
LDKUpdateFailMalformedHTLC o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UpdateFailMalformedHTLC_clone(&o_conv);
LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(orig & ~1);
LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
LDKUpdateFee o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UpdateFee_clone(&o_conv);
LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
*ret_conv = CResult_UpdateFeeDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
*ret_conv = CResult_UpdateFeeDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_UpdateFeeDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UpdateFeeDecodeErrorZ* o_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateFeeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_UpdateFeeDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UpdateFeeDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
+ *ret_conv = CResult_UpdateFeeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UpdateFeeDecodeErrorZ* arg_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFeeDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_UpdateFeeDecodeErrorZ* orig_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(orig & ~1);
LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
LDKUpdateFulfillHTLC o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UpdateFulfillHTLC_clone(&o_conv);
LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_UpdateFulfillHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(orig & ~1);
LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
LDKUpdateAddHTLC o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UpdateAddHTLC_clone(&o_conv);
LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
*ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UpdateAddHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UpdateAddHTLCDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
+ *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UpdateAddHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_UpdateAddHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(orig & ~1);
LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
LDKPing o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Ping_clone(&o_conv);
LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
*ret_conv = CResult_PingDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
*ret_conv = CResult_PingDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_PingDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PingDecodeErrorZ* o_conv = (LDKCResult_PingDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PingDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_PingDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PingDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
+ *ret_conv = CResult_PingDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PingDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PingDecodeErrorZ* arg_conv = (LDKCResult_PingDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PingDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_PingDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_PingDecodeErrorZ* orig_conv = (LDKCResult_PingDecodeErrorZ*)(orig & ~1);
LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
LDKPong o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Pong_clone(&o_conv);
LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
*ret_conv = CResult_PongDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
*ret_conv = CResult_PongDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_PongDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_PongDecodeErrorZ* o_conv = (LDKCResult_PongDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_PongDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_PongDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_PongDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
+ *ret_conv = CResult_PongDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_PongDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_PongDecodeErrorZ* arg_conv = (LDKCResult_PongDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_PongDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_PongDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_PongDecodeErrorZ* orig_conv = (LDKCResult_PongDecodeErrorZ*)(orig & ~1);
LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
LDKUnsignedChannelAnnouncement o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UnsignedChannelAnnouncement_clone(&o_conv);
LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
*ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
*ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* o_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(orig & ~1);
LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
LDKChannelAnnouncement o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelAnnouncement_clone(&o_conv);
LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
*ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
*ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelAnnouncementDecodeErrorZ* o_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelAnnouncementDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ChannelAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
LDKUnsignedChannelUpdate o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UnsignedChannelUpdate_clone(&o_conv);
LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
*ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
*ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ* o_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
+ *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ* arg_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_UnsignedChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(orig & ~1);
LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
LDKChannelUpdate o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ChannelUpdate_clone(&o_conv);
LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
*ret_conv = CResult_ChannelUpdateDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
*ret_conv = CResult_ChannelUpdateDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ChannelUpdateDecodeErrorZ* o_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ChannelUpdateDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ChannelUpdateDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ChannelUpdateDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
+ *ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ChannelUpdateDecodeErrorZ* arg_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelUpdateDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(orig & ~1);
LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
LDKErrorMessage o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ErrorMessage_clone(&o_conv);
LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
*ret_conv = CResult_ErrorMessageDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
*ret_conv = CResult_ErrorMessageDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ErrorMessageDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ErrorMessageDecodeErrorZ* o_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ErrorMessageDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ErrorMessageDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ErrorMessageDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
+ *ret_conv = CResult_ErrorMessageDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ErrorMessageDecodeErrorZ* arg_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ErrorMessageDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ErrorMessageDecodeErrorZ* orig_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(orig & ~1);
LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
LDKUnsignedNodeAnnouncement o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = UnsignedNodeAnnouncement_clone(&o_conv);
LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
*ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
*ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* o_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(orig & ~1);
LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
LDKNodeAnnouncement o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = NodeAnnouncement_clone(&o_conv);
LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
*ret_conv = CResult_NodeAnnouncementDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
*ret_conv = CResult_NodeAnnouncementDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_NodeAnnouncementDecodeErrorZ* o_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_NodeAnnouncementDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_NodeAnnouncementDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
+ *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_NodeAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_NodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(orig & ~1);
LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
LDKQueryShortChannelIds o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = QueryShortChannelIds_clone(&o_conv);
LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
*ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
*ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ* o_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_QueryShortChannelIdsDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
+ *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ* arg_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_QueryShortChannelIdsDecodeErrorZ* orig_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(orig & ~1);
LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
LDKReplyShortChannelIdsEnd o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ReplyShortChannelIdsEnd_clone(&o_conv);
LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
*ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
*ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* o_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
+ *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* arg_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* orig_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(orig & ~1);
LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
LDKQueryChannelRange o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = QueryChannelRange_clone(&o_conv);
LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
*ret_conv = CResult_QueryChannelRangeDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
*ret_conv = CResult_QueryChannelRangeDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_QueryChannelRangeDecodeErrorZ* o_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_QueryChannelRangeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_QueryChannelRangeDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_QueryChannelRangeDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
+ *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_QueryChannelRangeDecodeErrorZ* arg_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_QueryChannelRangeDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_QueryChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(orig & ~1);
LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
LDKReplyChannelRange o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = ReplyChannelRange_clone(&o_conv);
LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
*ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
*ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_ReplyChannelRangeDecodeErrorZ* o_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_ReplyChannelRangeDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
+ *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_ReplyChannelRangeDecodeErrorZ* arg_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_ReplyChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(orig & ~1);
LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
LDKGossipTimestampFilter o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = GossipTimestampFilter_clone(&o_conv);
LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
*ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_ok(o_conv);
LDKDecodeError e_conv;
e_conv.inner = (void*)(e & (~1));
e_conv.is_owned = (e & 1) || (e == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
e_conv = DecodeError_clone(&e_conv);
LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
*ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_err(e_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(uint32_t o) {
+ LDKCResult_GossipTimestampFilterDecodeErrorZ* o_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_GossipTimestampFilterDecodeErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg) {
+ LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
+ *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_GossipTimestampFilterDecodeErrorZ* arg_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(uint32_t orig) {
LDKCResult_GossipTimestampFilterDecodeErrorZ* orig_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(orig & ~1);
LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
LDKInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
o_conv = Invoice_clone(&o_conv);
LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
*ret_conv = CResult_InvoiceSignOrCreationErrorZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(uint32_t o) {
+ LDKCResult_InvoiceSignOrCreationErrorZ* o_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)(o & ~1);
+ jboolean ret_val = CResult_InvoiceSignOrCreationErrorZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_InvoiceSignOrCreationErrorZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
CResult_InvoiceSignOrCreationErrorZ_free(_res_conv);
}
+static inline uint64_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg) {
+ LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
+ *ret_conv = CResult_InvoiceSignOrCreationErrorZ_clone(arg);
+ return (uint64_t)ret_conv;
+}
+int64_t __attribute__((visibility("default"))) TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(uint32_t arg) {
+ LDKCResult_InvoiceSignOrCreationErrorZ* arg_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)(arg & ~1);
+ int64_t ret_val = CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceSignOrCreationErrorZ_clone(uint32_t orig) {
LDKCResult_InvoiceSignOrCreationErrorZ* orig_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)(orig & ~1);
LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
LDKLockedChannelMonitor o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = (o & 1) || (o == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
// Warning: we need a move here but no clone is available for LDKLockedChannelMonitor
LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
*ret_conv = CResult_LockedChannelMonitorNoneZ_ok(o_conv);
return (uint64_t)ret_conv;
}
+jboolean __attribute__((visibility("default"))) TS_CResult_LockedChannelMonitorNoneZ_is_ok(uint32_t o) {
+ LDKCResult_LockedChannelMonitorNoneZ* o_conv = (LDKCResult_LockedChannelMonitorNoneZ*)(o & ~1);
+ jboolean ret_val = CResult_LockedChannelMonitorNoneZ_is_ok(o_conv);
+ return ret_val;
+}
+
void __attribute__((visibility("default"))) TS_CResult_LockedChannelMonitorNoneZ_free(uint32_t _res) {
if ((_res & 1) != 0) return;
void* _res_ptr = (void*)(((uint64_t)_res) & ~1);
LDKOutPoint _res_conv_10_conv;
_res_conv_10_conv.inner = (void*)(_res_conv_10 & (~1));
_res_conv_10_conv.is_owned = (_res_conv_10 & 1) || (_res_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_10_conv);
_res_constr.data[k] = _res_conv_10_conv;
}
CVec_OutPointZ_free(_res_constr);
PaymentPurpose_free(this_ptr_conv);
}
+static inline uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg) {
+ LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
+ *ret_copy = PaymentPurpose_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_PaymentPurpose_clone_ptr(uint32_t arg) {
+ LDKPaymentPurpose* arg_conv = (LDKPaymentPurpose*)arg;
+ int64_t ret_val = PaymentPurpose_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_PaymentPurpose_clone(uint32_t orig) {
LDKPaymentPurpose* orig_conv = (LDKPaymentPurpose*)orig;
LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
ClosureReason_free(this_ptr_conv);
}
+static inline uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg) {
+ LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
+ *ret_copy = ClosureReason_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ClosureReason_clone_ptr(uint32_t arg) {
+ LDKClosureReason* arg_conv = (LDKClosureReason*)arg;
+ int64_t ret_val = ClosureReason_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ClosureReason_clone(uint32_t orig) {
LDKClosureReason* orig_conv = (LDKClosureReason*)orig;
LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
return ret_arr;
}
+uint32_t __attribute__((visibility("default"))) TS_ClosureReason_read(int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = *((uint32_t*)ser);
+ ser_ref.data = (int8_t*)(ser + 4);
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
+ *ret_conv = ClosureReason_read(ser_ref);
+ return (uint64_t)ret_conv;
+}
+
void __attribute__((visibility("default"))) TS_Event_free(uint32_t this_ptr) {
if ((this_ptr & 1) != 0) return;
void* this_ptr_ptr = (void*)(((uint64_t)this_ptr) & ~1);
Event_free(this_ptr_conv);
}
+static inline uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg) {
+ LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
+ *ret_copy = Event_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Event_clone_ptr(uint32_t arg) {
+ LDKEvent* arg_conv = (LDKEvent*)arg;
+ int64_t ret_val = Event_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Event_clone(uint32_t orig) {
LDKEvent* orig_conv = (LDKEvent*)orig;
LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
LDKRouteHop path_conv_10_conv;
path_conv_10_conv.inner = (void*)(path_conv_10 & (~1));
path_conv_10_conv.is_owned = (path_conv_10 & 1) || (path_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
path_constr.data[k] = path_conv_10_conv;
}
LDKRouteParameters retry_conv;
retry_conv.inner = (void*)(retry & (~1));
retry_conv.is_owned = (retry & 1) || (retry == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(retry_conv);
retry_conv = RouteParameters_clone(&retry_conv);
LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
*ret_copy = Event_payment_path_failed(payment_id_ref, payment_hash_ref, rejected_by_dest, network_update_conv, all_paths_failed, path_constr, short_channel_id_conv, retry_conv);
return ret_arr;
}
+uint32_t __attribute__((visibility("default"))) TS_Event_read(int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = *((uint32_t*)ser);
+ ser_ref.data = (int8_t*)(ser + 4);
+ LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
+ *ret_conv = Event_read(ser_ref);
+ return (uint64_t)ret_conv;
+}
+
void __attribute__((visibility("default"))) TS_MessageSendEvent_free(uint32_t this_ptr) {
if ((this_ptr & 1) != 0) return;
void* this_ptr_ptr = (void*)(((uint64_t)this_ptr) & ~1);
MessageSendEvent_free(this_ptr_conv);
}
+static inline uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg) {
+ LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
+ *ret_copy = MessageSendEvent_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_MessageSendEvent_clone_ptr(uint32_t arg) {
+ LDKMessageSendEvent* arg_conv = (LDKMessageSendEvent*)arg;
+ int64_t ret_val = MessageSendEvent_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_clone(uint32_t orig) {
LDKMessageSendEvent* orig_conv = (LDKMessageSendEvent*)orig;
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
LDKAcceptChannel msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = AcceptChannel_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_accept_channel(node_id_ref, msg_conv);
LDKOpenChannel msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = OpenChannel_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_open_channel(node_id_ref, msg_conv);
LDKFundingCreated msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = FundingCreated_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_funding_created(node_id_ref, msg_conv);
LDKFundingSigned msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = FundingSigned_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_funding_signed(node_id_ref, msg_conv);
LDKFundingLocked msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = FundingLocked_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_funding_locked(node_id_ref, msg_conv);
LDKAnnouncementSignatures msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = AnnouncementSignatures_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_announcement_signatures(node_id_ref, msg_conv);
LDKCommitmentUpdate updates_conv;
updates_conv.inner = (void*)(updates & (~1));
updates_conv.is_owned = (updates & 1) || (updates == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_conv);
updates_conv = CommitmentUpdate_clone(&updates_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_update_htlcs(node_id_ref, updates_conv);
LDKRevokeAndACK msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = RevokeAndACK_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_revoke_and_ack(node_id_ref, msg_conv);
LDKClosingSigned msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ClosingSigned_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_closing_signed(node_id_ref, msg_conv);
LDKShutdown msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = Shutdown_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_shutdown(node_id_ref, msg_conv);
LDKChannelReestablish msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ChannelReestablish_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_channel_reestablish(node_id_ref, msg_conv);
LDKChannelAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ChannelAnnouncement_clone(&msg_conv);
LDKChannelUpdate update_msg_conv;
update_msg_conv.inner = (void*)(update_msg & (~1));
update_msg_conv.is_owned = (update_msg & 1) || (update_msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_conv);
update_msg_conv = ChannelUpdate_clone(&update_msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_broadcast_channel_announcement(msg_conv, update_msg_conv);
LDKNodeAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = NodeAnnouncement_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_broadcast_node_announcement(msg_conv);
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ChannelUpdate_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_broadcast_channel_update(msg_conv);
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ChannelUpdate_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_channel_update(node_id_ref, msg_conv);
LDKQueryChannelRange msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = QueryChannelRange_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_channel_range_query(node_id_ref, msg_conv);
LDKQueryShortChannelIds msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = QueryShortChannelIds_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_short_ids_query(node_id_ref, msg_conv);
LDKReplyChannelRange msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ReplyChannelRange_clone(&msg_conv);
LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
*ret_copy = MessageSendEvent_send_reply_channel_range(node_id_ref, msg_conv);
APIError_free(this_ptr_conv);
}
+static inline uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg) {
+ LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
+ *ret_copy = APIError_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_APIError_clone_ptr(uint32_t arg) {
+ LDKAPIError* arg_conv = (LDKAPIError*)arg;
+ int64_t ret_val = APIError_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_APIError_clone(uint32_t orig) {
LDKAPIError* orig_conv = (LDKAPIError*)orig;
LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
LDKShutdownScript script_conv;
script_conv.inner = (void*)(script & (~1));
script_conv.is_owned = (script & 1) || (script == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(script_conv);
script_conv = ShutdownScript_clone(&script_conv);
LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
*ret_copy = APIError_incompatible_shutdown_script(script_conv);
return ret_conv;
}
+void __attribute__((visibility("default"))) TS_Record_free(uint32_t this_obj) {
+ LDKRecord this_obj_conv;
+ this_obj_conv.inner = (void*)(this_obj & (~1));
+ this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
+ Record_free(this_obj_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Record_get_level(uint32_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ uint32_t ret_conv = LDKLevel_to_js(Record_get_level(&this_ptr_conv));
+ return ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_Record_set_level(uint32_t this_ptr, uint32_t val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKLevel val_conv = LDKLevel_from_js(val);
+ Record_set_level(&this_ptr_conv, val_conv);
+}
+
+jstring __attribute__((visibility("default"))) TS_Record_get_args(uint32_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr ret_str = Record_get_args(&this_ptr_conv);
+ jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
+ Str_free(ret_str);
+ return ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_Record_set_args(uint32_t this_ptr, jstring val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr val_conv = str_ref_to_owned_c(val);
+ Record_set_args(&this_ptr_conv, val_conv);
+}
+
+jstring __attribute__((visibility("default"))) TS_Record_get_module_path(uint32_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr ret_str = Record_get_module_path(&this_ptr_conv);
+ jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
+ Str_free(ret_str);
+ return ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_Record_set_module_path(uint32_t this_ptr, jstring val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr val_conv = str_ref_to_owned_c(val);
+ Record_set_module_path(&this_ptr_conv, val_conv);
+}
+
+jstring __attribute__((visibility("default"))) TS_Record_get_file(uint32_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr ret_str = Record_get_file(&this_ptr_conv);
+ jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
+ Str_free(ret_str);
+ return ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_Record_set_file(uint32_t this_ptr, jstring val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKStr val_conv = str_ref_to_owned_c(val);
+ Record_set_file(&this_ptr_conv, val_conv);
+}
+
+int32_t __attribute__((visibility("default"))) TS_Record_get_line(uint32_t this_ptr) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ int32_t ret_val = Record_get_line(&this_ptr_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_Record_set_line(uint32_t this_ptr, int32_t val) {
+ LDKRecord this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ Record_set_line(&this_ptr_conv, val);
+}
+
+static inline uint64_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg) {
+ LDKRecord ret_var = Record_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Record_clone_ptr(uint32_t arg) {
+ LDKRecord arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Record_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Record_clone(uint32_t orig) {
+ LDKRecord orig_conv;
+ orig_conv.inner = (void*)(orig & (~1));
+ orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
+ LDKRecord ret_var = Record_clone(&orig_conv);
+ uint64_t ret_ref = 0;
+ CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = (uint64_t)ret_var.inner;
+ if (ret_var.is_owned) {
+ ret_ref |= 1;
+ }
+ return ret_ref;
+}
+
void __attribute__((visibility("default"))) TS_Logger_free(uint32_t this_ptr) {
if ((this_ptr & 1) != 0) return;
void* this_ptr_ptr = (void*)(((uint64_t)this_ptr) & ~1);
LDKChannelHandshakeConfig this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelHandshakeConfig_free(this_obj_conv);
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ChannelHandshakeConfig_get_minimum_depth(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeConfig_set_minimum_depth(&this_ptr_conv, val);
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = ChannelHandshakeConfig_get_our_to_self_delay(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeConfig_set_our_to_self_delay(&this_ptr_conv, val);
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelHandshakeConfig_get_our_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeConfig_set_our_htlc_minimum_msat(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg) {
+ LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_clone_ptr(uint32_t arg) {
+ LDKChannelHandshakeConfig arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelHandshakeConfig_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_clone(uint32_t orig) {
LDKChannelHandshakeConfig orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelHandshakeLimits this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelHandshakeLimits_free(this_obj_conv);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelHandshakeLimits_get_min_funding_satoshis(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_min_funding_satoshis(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelHandshakeLimits_get_max_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_max_htlc_minimum_msat(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelHandshakeLimits_get_max_channel_reserve_satoshis(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_max_channel_reserve_satoshis(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = ChannelHandshakeLimits_get_min_max_accepted_htlcs(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_min_max_accepted_htlcs(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ChannelHandshakeLimits_get_max_minimum_depth(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_max_minimum_depth(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelHandshakeLimits_get_force_announced_channel_preference(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_force_announced_channel_preference(&this_ptr_conv, val);
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = ChannelHandshakeLimits_get_their_to_self_delay(&this_ptr_conv);
return ret_val;
}
LDKChannelHandshakeLimits this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelHandshakeLimits_set_their_to_self_delay(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg) {
+ LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_clone_ptr(uint32_t arg) {
+ LDKChannelHandshakeLimits arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelHandshakeLimits_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_clone(uint32_t orig) {
LDKChannelHandshakeLimits orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelConfig this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelConfig_free(this_obj_conv);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ChannelConfig_get_forwarding_fee_proportional_millionths(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_forwarding_fee_proportional_millionths(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ChannelConfig_get_forwarding_fee_base_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_forwarding_fee_base_msat(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = ChannelConfig_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelConfig_get_announced_channel(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_announced_channel(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelConfig_get_commit_upfront_shutdown_pubkey(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_commit_upfront_shutdown_pubkey(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelConfig_get_max_dust_htlc_exposure_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_max_dust_htlc_exposure_msat(&this_ptr_conv, val);
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelConfig_get_force_close_avoidance_max_fee_satoshis(&this_ptr_conv);
return ret_val;
}
LDKChannelConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelConfig_set_force_close_avoidance_max_fee_satoshis(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg) {
+ LDKChannelConfig ret_var = ChannelConfig_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelConfig_clone_ptr(uint32_t arg) {
+ LDKChannelConfig arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelConfig_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelConfig_clone(uint32_t orig) {
LDKChannelConfig orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelConfig ret_var = ChannelConfig_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelConfig obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelConfig_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKUserConfig this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UserConfig_free(this_obj_conv);
}
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelHandshakeConfig ret_var = UserConfig_get_own_channel_config(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelHandshakeConfig val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelHandshakeConfig_clone(&val_conv);
UserConfig_set_own_channel_config(&this_ptr_conv, val_conv);
}
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelHandshakeLimits ret_var = UserConfig_get_peer_channel_config_limits(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelHandshakeLimits val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelHandshakeLimits_clone(&val_conv);
UserConfig_set_peer_channel_config_limits(&this_ptr_conv, val_conv);
}
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelConfig ret_var = UserConfig_get_channel_options(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelConfig val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelConfig_clone(&val_conv);
UserConfig_set_channel_options(&this_ptr_conv, val_conv);
}
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = UserConfig_get_accept_forwards_to_priv_channels(&this_ptr_conv);
return ret_val;
}
LDKUserConfig this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UserConfig_set_accept_forwards_to_priv_channels(&this_ptr_conv, val);
}
LDKChannelHandshakeConfig own_channel_config_arg_conv;
own_channel_config_arg_conv.inner = (void*)(own_channel_config_arg & (~1));
own_channel_config_arg_conv.is_owned = (own_channel_config_arg & 1) || (own_channel_config_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(own_channel_config_arg_conv);
own_channel_config_arg_conv = ChannelHandshakeConfig_clone(&own_channel_config_arg_conv);
LDKChannelHandshakeLimits peer_channel_config_limits_arg_conv;
peer_channel_config_limits_arg_conv.inner = (void*)(peer_channel_config_limits_arg & (~1));
peer_channel_config_limits_arg_conv.is_owned = (peer_channel_config_limits_arg & 1) || (peer_channel_config_limits_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(peer_channel_config_limits_arg_conv);
peer_channel_config_limits_arg_conv = ChannelHandshakeLimits_clone(&peer_channel_config_limits_arg_conv);
LDKChannelConfig channel_options_arg_conv;
channel_options_arg_conv.inner = (void*)(channel_options_arg & (~1));
channel_options_arg_conv.is_owned = (channel_options_arg & 1) || (channel_options_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_options_arg_conv);
channel_options_arg_conv = ChannelConfig_clone(&channel_options_arg_conv);
LDKUserConfig ret_var = UserConfig_new(own_channel_config_arg_conv, peer_channel_config_limits_arg_conv, channel_options_arg_conv, accept_forwards_to_priv_channels_arg);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg) {
+ LDKUserConfig ret_var = UserConfig_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_UserConfig_clone_ptr(uint32_t arg) {
+ LDKUserConfig arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UserConfig_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_UserConfig_clone(uint32_t orig) {
LDKUserConfig orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUserConfig ret_var = UserConfig_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKBestBlock this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
BestBlock_free(this_obj_conv);
}
+static inline uint64_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg) {
+ LDKBestBlock ret_var = BestBlock_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_BestBlock_clone_ptr(uint32_t arg) {
+ LDKBestBlock arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = BestBlock_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_BestBlock_clone(uint32_t orig) {
LDKBestBlock orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKBestBlock ret_var = BestBlock_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKBestBlock this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), BestBlock_block_hash(&this_arg_conv).data, 32);
return ret_arr;
LDKBestBlock this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int32_t ret_val = BestBlock_height(&this_arg_conv);
return ret_val;
}
LDKWatchedOutput this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
WatchedOutput_free(this_obj_conv);
}
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), WatchedOutput_get_block_hash(&this_ptr_conv).data, 32);
return ret_arr;
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint ret_var = WatchedOutput_get_outpoint(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = OutPoint_clone(&val_conv);
WatchedOutput_set_outpoint(&this_ptr_conv, val_conv);
}
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKu8slice ret_var = WatchedOutput_get_script_pubkey(&this_ptr_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKWatchedOutput this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u8Z val_ref;
val_ref.datalen = *((uint32_t*)val);
val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
LDKOutPoint outpoint_arg_conv;
outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
LDKCVec_u8Z script_pubkey_arg_ref;
script_pubkey_arg_ref.datalen = *((uint32_t*)script_pubkey_arg);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg) {
+ LDKWatchedOutput ret_var = WatchedOutput_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_WatchedOutput_clone_ptr(uint32_t arg) {
+ LDKWatchedOutput arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = WatchedOutput_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_WatchedOutput_clone(uint32_t orig) {
LDKWatchedOutput orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKWatchedOutput ret_var = WatchedOutput_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKWatchedOutput o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = WatchedOutput_hash(&o_conv);
return ret_val;
}
LDKMonitorUpdateId this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
MonitorUpdateId_free(this_obj_conv);
}
+static inline uint64_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg) {
+ LDKMonitorUpdateId ret_var = MonitorUpdateId_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_MonitorUpdateId_clone_ptr(uint32_t arg) {
+ LDKMonitorUpdateId arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = MonitorUpdateId_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_MonitorUpdateId_clone(uint32_t orig) {
LDKMonitorUpdateId orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKMonitorUpdateId ret_var = MonitorUpdateId_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKMonitorUpdateId o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = MonitorUpdateId_hash(&o_conv);
return ret_val;
}
LDKMonitorUpdateId a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKMonitorUpdateId b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = MonitorUpdateId_eq(&a_conv, &b_conv);
return ret_val;
}
LDKLockedChannelMonitor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
LockedChannelMonitor_free(this_obj_conv);
}
LDKChainMonitor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChainMonitor_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_ChannelDetailsZ ignored_channels_constr;
ignored_channels_constr.datalen = *((uint32_t*)ignored_channels);
if (ignored_channels_constr.datalen > 0)
LDKChannelDetails ignored_channels_conv_16_conv;
ignored_channels_conv_16_conv.inner = (void*)(ignored_channels_conv_16 & (~1));
ignored_channels_conv_16_conv.is_owned = (ignored_channels_conv_16 & 1) || (ignored_channels_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ignored_channels_conv_16_conv);
ignored_channels_conv_16_conv = ChannelDetails_clone(&ignored_channels_conv_16_conv);
ignored_channels_constr.data[q] = ignored_channels_conv_16_conv;
}
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKOutPoint funding_txo_conv;
funding_txo_conv.inner = (void*)(funding_txo & (~1));
funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
funding_txo_conv = OutPoint_clone(&funding_txo_conv);
LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
*ret_conv = ChainMonitor_get_monitor(&this_arg_conv, funding_txo_conv);
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_OutPointZ ret_var = ChainMonitor_list_monitors(&this_arg_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_10_ref = 0;
CHECK((((uint64_t)ret_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_10_var);
ret_conv_10_ref = (uint64_t)ret_conv_10_var.inner;
if (ret_conv_10_var.is_owned) {
ret_conv_10_ref |= 1;
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKOutPoint funding_txo_conv;
funding_txo_conv.inner = (void*)(funding_txo & (~1));
funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
funding_txo_conv = OutPoint_clone(&funding_txo_conv);
LDKMonitorUpdateId completed_update_id_conv;
completed_update_id_conv.inner = (void*)(completed_update_id & (~1));
completed_update_id_conv.is_owned = (completed_update_id & 1) || (completed_update_id == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(completed_update_id_conv);
completed_update_id_conv = MonitorUpdateId_clone(&completed_update_id_conv);
LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
*ret_conv = ChainMonitor_channel_monitor_updated(&this_arg_conv, funding_txo_conv, completed_update_id_conv);
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKListen* ret_ret = MALLOC(sizeof(LDKListen), "LDKListen");
*ret_ret = ChainMonitor_as_Listen(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKConfirm* ret_ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
*ret_ret = ChainMonitor_as_Confirm(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKWatch* ret_ret = MALLOC(sizeof(LDKWatch), "LDKWatch");
*ret_ret = ChainMonitor_as_Watch(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChainMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKEventsProvider* ret_ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
*ret_ret = ChainMonitor_as_EventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelMonitorUpdate this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelMonitorUpdate_free(this_obj_conv);
}
LDKChannelMonitorUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelMonitorUpdate_get_update_id(&this_ptr_conv);
return ret_val;
}
LDKChannelMonitorUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelMonitorUpdate_set_update_id(&this_ptr_conv, val);
}
+static inline uint64_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg) {
+ LDKChannelMonitorUpdate ret_var = ChannelMonitorUpdate_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelMonitorUpdate_clone_ptr(uint32_t arg) {
+ LDKChannelMonitorUpdate arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelMonitorUpdate_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelMonitorUpdate_clone(uint32_t orig) {
LDKChannelMonitorUpdate orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelMonitorUpdate ret_var = ChannelMonitorUpdate_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelMonitorUpdate obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelMonitorUpdate_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKMonitorUpdateError this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
MonitorUpdateError_free(this_obj_conv);
}
LDKMonitorUpdateError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr ret_str = MonitorUpdateError_get_a(&this_ptr_conv);
jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
Str_free(ret_str);
LDKMonitorUpdateError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr val_conv = str_ref_to_owned_c(val);
MonitorUpdateError_set_a(&this_ptr_conv, val_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t MonitorUpdateError_clone_ptr(LDKMonitorUpdateError *NONNULL_PTR arg) {
+ LDKMonitorUpdateError ret_var = MonitorUpdateError_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_MonitorUpdateError_clone_ptr(uint32_t arg) {
+ LDKMonitorUpdateError arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = MonitorUpdateError_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_MonitorUpdateError_clone(uint32_t orig) {
LDKMonitorUpdateError orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKMonitorUpdateError ret_var = MonitorUpdateError_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
MonitorEvent_free(this_ptr_conv);
}
+static inline uint64_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg) {
+ LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
+ *ret_copy = MonitorEvent_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_MonitorEvent_clone_ptr(uint32_t arg) {
+ LDKMonitorEvent* arg_conv = (LDKMonitorEvent*)arg;
+ int64_t ret_val = MonitorEvent_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_MonitorEvent_clone(uint32_t orig) {
LDKMonitorEvent* orig_conv = (LDKMonitorEvent*)orig;
LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
LDKHTLCUpdate a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = HTLCUpdate_clone(&a_conv);
LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
*ret_copy = MonitorEvent_htlcevent(a_conv);
LDKOutPoint a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = OutPoint_clone(&a_conv);
LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
*ret_copy = MonitorEvent_commitment_tx_confirmed(a_conv);
LDKOutPoint funding_txo_conv;
funding_txo_conv.inner = (void*)(funding_txo & (~1));
funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
funding_txo_conv = OutPoint_clone(&funding_txo_conv);
LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
*ret_copy = MonitorEvent_update_completed(funding_txo_conv, monitor_update_id);
LDKOutPoint a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = OutPoint_clone(&a_conv);
LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
*ret_copy = MonitorEvent_update_failed(a_conv);
return ret_arr;
}
+uint32_t __attribute__((visibility("default"))) TS_MonitorEvent_read(int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = *((uint32_t*)ser);
+ ser_ref.data = (int8_t*)(ser + 4);
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
+ *ret_conv = MonitorEvent_read(ser_ref);
+ return (uint64_t)ret_conv;
+}
+
void __attribute__((visibility("default"))) TS_HTLCUpdate_free(uint32_t this_obj) {
LDKHTLCUpdate this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
HTLCUpdate_free(this_obj_conv);
}
+static inline uint64_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg) {
+ LDKHTLCUpdate ret_var = HTLCUpdate_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_HTLCUpdate_clone_ptr(uint32_t arg) {
+ LDKHTLCUpdate arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = HTLCUpdate_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_HTLCUpdate_clone(uint32_t orig) {
LDKHTLCUpdate orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKHTLCUpdate ret_var = HTLCUpdate_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKHTLCUpdate obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = HTLCUpdate_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
Balance_free(this_ptr_conv);
}
+static inline uint64_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg) {
+ LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
+ *ret_copy = Balance_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Balance_clone_ptr(uint32_t arg) {
+ LDKBalance* arg_conv = (LDKBalance*)arg;
+ int64_t ret_val = Balance_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Balance_clone(uint32_t orig) {
LDKBalance* orig_conv = (LDKBalance*)orig;
LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
LDKChannelMonitor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelMonitor_free(this_obj_conv);
}
+static inline uint64_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg) {
+ LDKChannelMonitor ret_var = ChannelMonitor_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelMonitor_clone_ptr(uint32_t arg) {
+ LDKChannelMonitor arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelMonitor_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelMonitor_clone(uint32_t orig) {
LDKChannelMonitor orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelMonitor ret_var = ChannelMonitor_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelMonitor obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelMonitor_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelMonitorUpdate updates_conv;
updates_conv.inner = (void*)(updates & (~1));
updates_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_conv);
void* broadcaster_ptr = (void*)(((uint64_t)broadcaster) & ~1);
if (!(broadcaster & 1)) { CHECK_ACCESS(broadcaster_ptr); }
LDKBroadcasterInterface* broadcaster_conv = (LDKBroadcasterInterface*)broadcaster_ptr;
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = ChannelMonitor_get_latest_update_id(&this_arg_conv);
return ret_val;
}
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
*ret_conv = ChannelMonitor_get_funding_txo(&this_arg_conv);
return ((uint64_t)ret_conv);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ret_var = ChannelMonitor_get_outputs_to_watch(&this_arg_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* filter_ptr = (void*)(((uint64_t)filter) & ~1);
if (!(filter & 1)) { CHECK_ACCESS(filter_ptr); }
LDKFilter* filter_conv = (LDKFilter*)filter_ptr;
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_MonitorEventZ ret_var = ChannelMonitor_get_and_clear_pending_monitor_events(&this_arg_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_EventZ ret_var = ChannelMonitor_get_and_clear_pending_events(&this_arg_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* logger_ptr = (void*)(((uint64_t)logger) & ~1);
if (!(logger & 1)) { CHECK_ACCESS(logger_ptr); }
LDKLogger* logger_conv = (LDKLogger*)logger_ptr;
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char header_arr[80];
CHECK(*((uint32_t*)header) == 80);
memcpy(header_arr, (uint8_t*)(header + 4), 80);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char header_arr[80];
CHECK(*((uint32_t*)header) == 80);
memcpy(header_arr, (uint8_t*)(header + 4), 80);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char header_arr[80];
CHECK(*((uint32_t*)header) == 80);
memcpy(header_arr, (uint8_t*)(header + 4), 80);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char txid_arr[32];
CHECK(*((uint32_t*)txid) == 32);
memcpy(txid_arr, (uint8_t*)(txid + 4), 32);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char header_arr[80];
CHECK(*((uint32_t*)header) == 80);
memcpy(header_arr, (uint8_t*)(header + 4), 80);
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_TxidZ ret_var = ChannelMonitor_get_relevant_txids(&this_arg_conv);
ptrArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native ptrArray Bytes");
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKBestBlock ret_var = ChannelMonitor_current_best_block(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelMonitor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_BalanceZ ret_var = ChannelMonitor_get_claimable_balances(&this_arg_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
LDKOutPoint this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
OutPoint_free(this_obj_conv);
}
LDKOutPoint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *OutPoint_get_txid(&this_ptr_conv), 32);
return ret_arr;
LDKOutPoint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKOutPoint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = OutPoint_get_index(&this_ptr_conv);
return ret_val;
}
LDKOutPoint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OutPoint_set_index(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg) {
+ LDKOutPoint ret_var = OutPoint_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_OutPoint_clone_ptr(uint32_t arg) {
+ LDKOutPoint arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = OutPoint_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_OutPoint_clone(uint32_t orig) {
LDKOutPoint orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKOutPoint ret_var = OutPoint_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKOutPoint a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKOutPoint b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = OutPoint_eq(&a_conv, &b_conv);
return ret_val;
}
LDKOutPoint o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = OutPoint_hash(&o_conv);
return ret_val;
}
LDKOutPoint this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), OutPoint_to_channel_id(&this_arg_conv).data, 32);
return ret_arr;
LDKOutPoint obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = OutPoint_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKDelayedPaymentOutputDescriptor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DelayedPaymentOutputDescriptor_free(this_obj_conv);
}
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint ret_var = DelayedPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = OutPoint_clone(&val_conv);
DelayedPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
}
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), DelayedPaymentOutputDescriptor_get_per_commitment_point(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = DelayedPaymentOutputDescriptor_get_to_self_delay(&this_ptr_conv);
return ret_val;
}
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DelayedPaymentOutputDescriptor_set_to_self_delay(&this_ptr_conv, val);
}
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKTxOut val_conv = *(LDKTxOut*)(val_ptr);
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), DelayedPaymentOutputDescriptor_get_revocation_pubkey(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *DelayedPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv), 32);
return ret_arr;
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = DelayedPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
return ret_val;
}
LDKDelayedPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DelayedPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
}
LDKOutPoint outpoint_arg_conv;
outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
LDKPublicKey per_commitment_point_arg_ref;
CHECK(*((uint32_t*)per_commitment_point_arg) == 33);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg) {
+ LDKDelayedPaymentOutputDescriptor ret_var = DelayedPaymentOutputDescriptor_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescriptor_clone_ptr(uint32_t arg) {
+ LDKDelayedPaymentOutputDescriptor arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = DelayedPaymentOutputDescriptor_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescriptor_clone(uint32_t orig) {
LDKDelayedPaymentOutputDescriptor orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKDelayedPaymentOutputDescriptor ret_var = DelayedPaymentOutputDescriptor_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDelayedPaymentOutputDescriptor obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = DelayedPaymentOutputDescriptor_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKStaticPaymentOutputDescriptor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
StaticPaymentOutputDescriptor_free(this_obj_conv);
}
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint ret_var = StaticPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = OutPoint_clone(&val_conv);
StaticPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
}
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKTxOut val_conv = *(LDKTxOut*)(val_ptr);
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *StaticPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv), 32);
return ret_arr;
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = StaticPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
return ret_val;
}
LDKStaticPaymentOutputDescriptor this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
StaticPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
}
LDKOutPoint outpoint_arg_conv;
outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
void* output_arg_ptr = (void*)(((uint64_t)output_arg) & ~1);
CHECK_ACCESS(output_arg_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg) {
+ LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_StaticPaymentOutputDescriptor_clone_ptr(uint32_t arg) {
+ LDKStaticPaymentOutputDescriptor arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = StaticPaymentOutputDescriptor_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_StaticPaymentOutputDescriptor_clone(uint32_t orig) {
LDKStaticPaymentOutputDescriptor orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKStaticPaymentOutputDescriptor obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = StaticPaymentOutputDescriptor_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
SpendableOutputDescriptor_free(this_ptr_conv);
}
+static inline uint64_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg) {
+ LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
+ *ret_copy = SpendableOutputDescriptor_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_SpendableOutputDescriptor_clone_ptr(uint32_t arg) {
+ LDKSpendableOutputDescriptor* arg_conv = (LDKSpendableOutputDescriptor*)arg;
+ int64_t ret_val = SpendableOutputDescriptor_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_SpendableOutputDescriptor_clone(uint32_t orig) {
LDKSpendableOutputDescriptor* orig_conv = (LDKSpendableOutputDescriptor*)orig;
LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
LDKOutPoint outpoint_conv;
outpoint_conv.inner = (void*)(outpoint & (~1));
outpoint_conv.is_owned = (outpoint & 1) || (outpoint == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_conv);
outpoint_conv = OutPoint_clone(&outpoint_conv);
void* output_ptr = (void*)(((uint64_t)output) & ~1);
CHECK_ACCESS(output_ptr);
LDKDelayedPaymentOutputDescriptor a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = DelayedPaymentOutputDescriptor_clone(&a_conv);
LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
*ret_copy = SpendableOutputDescriptor_delayed_payment_output(a_conv);
LDKStaticPaymentOutputDescriptor a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = StaticPaymentOutputDescriptor_clone(&a_conv);
LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
*ret_copy = SpendableOutputDescriptor_static_payment_output(a_conv);
BaseSign_free(this_ptr_conv);
}
+static inline uint64_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg) {
+ LDKSign* ret_ret = MALLOC(sizeof(LDKSign), "LDKSign");
+ *ret_ret = Sign_clone(arg);
+ return (uint64_t)ret_ret;
+}
+int64_t __attribute__((visibility("default"))) TS_Sign_clone_ptr(uint32_t arg) {
+ void* arg_ptr = (void*)(((uint64_t)arg) & ~1);
+ if (!(arg & 1)) { CHECK_ACCESS(arg_ptr); }
+ LDKSign* arg_conv = (LDKSign*)arg_ptr;
+ int64_t ret_val = Sign_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Sign_clone(uint32_t orig) {
void* orig_ptr = (void*)(((uint64_t)orig) & ~1);
if (!(orig & 1)) { CHECK_ACCESS(orig_ptr); }
LDKInMemorySigner this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InMemorySigner_free(this_obj_conv);
}
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *InMemorySigner_get_funding_key(&this_ptr_conv), 32);
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSecretKey val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.bytes, (uint8_t*)(val + 4), 32);
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *InMemorySigner_get_revocation_base_key(&this_ptr_conv), 32);
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSecretKey val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.bytes, (uint8_t*)(val + 4), 32);
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *InMemorySigner_get_payment_key(&this_ptr_conv), 32);
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSecretKey val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.bytes, (uint8_t*)(val + 4), 32);
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *InMemorySigner_get_delayed_payment_base_key(&this_ptr_conv), 32);
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSecretKey val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.bytes, (uint8_t*)(val + 4), 32);
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *InMemorySigner_get_htlc_base_key(&this_ptr_conv), 32);
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSecretKey val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.bytes, (uint8_t*)(val + 4), 32);
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *InMemorySigner_get_commitment_seed(&this_ptr_conv), 32);
return ret_arr;
LDKInMemorySigner this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
InMemorySigner_set_commitment_seed(&this_ptr_conv, val_ref);
}
+static inline uint64_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg) {
+ LDKInMemorySigner ret_var = InMemorySigner_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_InMemorySigner_clone_ptr(uint32_t arg) {
+ LDKInMemorySigner arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = InMemorySigner_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_InMemorySigner_clone(uint32_t orig) {
LDKInMemorySigner orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInMemorySigner ret_var = InMemorySigner_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelPublicKeys ret_var = InMemorySigner_counterparty_pubkeys(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int16_t ret_val = InMemorySigner_counterparty_selected_contest_delay(&this_arg_conv);
return ret_val;
}
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int16_t ret_val = InMemorySigner_holder_selected_contest_delay(&this_arg_conv);
return ret_val;
}
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = InMemorySigner_is_outbound(&this_arg_conv);
return ret_val;
}
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKOutPoint ret_var = InMemorySigner_funding_outpoint(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelTransactionParameters ret_var = InMemorySigner_get_channel_parameters(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTransaction spend_tx_ref;
spend_tx_ref.datalen = *((uint32_t*)spend_tx);
spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
LDKStaticPaymentOutputDescriptor descriptor_conv;
descriptor_conv.inner = (void*)(descriptor & (~1));
descriptor_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(descriptor_conv);
LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
*ret_conv = InMemorySigner_sign_counterparty_payment_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
return (uint64_t)ret_conv;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTransaction spend_tx_ref;
spend_tx_ref.datalen = *((uint32_t*)spend_tx);
spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
LDKDelayedPaymentOutputDescriptor descriptor_conv;
descriptor_conv.inner = (void*)(descriptor & (~1));
descriptor_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(descriptor_conv);
LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
*ret_conv = InMemorySigner_sign_dynamic_p2wsh_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
return (uint64_t)ret_conv;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKBaseSign* ret_ret = MALLOC(sizeof(LDKBaseSign), "LDKBaseSign");
*ret_ret = InMemorySigner_as_BaseSign(&this_arg_conv);
return (uint64_t)ret_ret;
LDKInMemorySigner this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKSign* ret_ret = MALLOC(sizeof(LDKSign), "LDKSign");
*ret_ret = InMemorySigner_as_Sign(&this_arg_conv);
return (uint64_t)ret_ret;
LDKInMemorySigner obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = InMemorySigner_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKKeysManager this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
KeysManager_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKKeysManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char params_arr[32];
CHECK(*((uint32_t*)params) == 32);
memcpy(params_arr, (uint8_t*)(params + 4), 32);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKKeysManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_SpendableOutputDescriptorZ descriptors_constr;
descriptors_constr.datalen = *((uint32_t*)descriptors);
if (descriptors_constr.datalen > 0)
LDKKeysManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKKeysInterface* ret_ret = MALLOC(sizeof(LDKKeysInterface), "LDKKeysInterface");
*ret_ret = KeysManager_as_KeysInterface(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelManager_free(this_obj_conv);
}
LDKChainParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChainParameters_free(this_obj_conv);
}
LDKChainParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
uint32_t ret_conv = LDKNetwork_to_js(ChainParameters_get_network(&this_ptr_conv));
return ret_conv;
}
LDKChainParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNetwork val_conv = LDKNetwork_from_js(val);
ChainParameters_set_network(&this_ptr_conv, val_conv);
}
LDKChainParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKBestBlock ret_var = ChainParameters_get_best_block(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChainParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKBestBlock val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = BestBlock_clone(&val_conv);
ChainParameters_set_best_block(&this_ptr_conv, val_conv);
}
LDKBestBlock best_block_arg_conv;
best_block_arg_conv.inner = (void*)(best_block_arg & (~1));
best_block_arg_conv.is_owned = (best_block_arg & 1) || (best_block_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(best_block_arg_conv);
best_block_arg_conv = BestBlock_clone(&best_block_arg_conv);
LDKChainParameters ret_var = ChainParameters_new(network_arg_conv, best_block_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg) {
+ LDKChainParameters ret_var = ChainParameters_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChainParameters_clone_ptr(uint32_t arg) {
+ LDKChainParameters arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChainParameters_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChainParameters_clone(uint32_t orig) {
LDKChainParameters orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChainParameters ret_var = ChainParameters_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCounterpartyForwardingInfo this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
CounterpartyForwardingInfo_free(this_obj_conv);
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = CounterpartyForwardingInfo_get_fee_base_msat(&this_ptr_conv);
return ret_val;
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
CounterpartyForwardingInfo_set_fee_base_msat(&this_ptr_conv, val);
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = CounterpartyForwardingInfo_get_fee_proportional_millionths(&this_ptr_conv);
return ret_val;
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
CounterpartyForwardingInfo_set_fee_proportional_millionths(&this_ptr_conv, val);
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = CounterpartyForwardingInfo_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKCounterpartyForwardingInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
CounterpartyForwardingInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg) {
+ LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_CounterpartyForwardingInfo_clone_ptr(uint32_t arg) {
+ LDKCounterpartyForwardingInfo arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = CounterpartyForwardingInfo_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CounterpartyForwardingInfo_clone(uint32_t orig) {
LDKCounterpartyForwardingInfo orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelCounterparty this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelCounterparty_free(this_obj_conv);
}
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelCounterparty_get_node_id(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInitFeatures ret_var = ChannelCounterparty_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInitFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = InitFeatures_clone(&val_conv);
ChannelCounterparty_set_features(&this_ptr_conv, val_conv);
}
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelCounterparty_get_unspendable_punishment_reserve(&this_ptr_conv);
return ret_val;
}
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelCounterparty_set_unspendable_punishment_reserve(&this_ptr_conv, val);
}
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCounterpartyForwardingInfo ret_var = ChannelCounterparty_get_forwarding_info(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelCounterparty this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCounterpartyForwardingInfo val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = CounterpartyForwardingInfo_clone(&val_conv);
ChannelCounterparty_set_forwarding_info(&this_ptr_conv, val_conv);
}
LDKInitFeatures features_arg_conv;
features_arg_conv.inner = (void*)(features_arg & (~1));
features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
features_arg_conv = InitFeatures_clone(&features_arg_conv);
LDKCounterpartyForwardingInfo forwarding_info_arg_conv;
forwarding_info_arg_conv.inner = (void*)(forwarding_info_arg & (~1));
forwarding_info_arg_conv.is_owned = (forwarding_info_arg & 1) || (forwarding_info_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(forwarding_info_arg_conv);
forwarding_info_arg_conv = CounterpartyForwardingInfo_clone(&forwarding_info_arg_conv);
LDKChannelCounterparty ret_var = ChannelCounterparty_new(node_id_arg_ref, features_arg_conv, unspendable_punishment_reserve_arg, forwarding_info_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg) {
+ LDKChannelCounterparty ret_var = ChannelCounterparty_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelCounterparty_clone_ptr(uint32_t arg) {
+ LDKChannelCounterparty arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelCounterparty_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelCounterparty_clone(uint32_t orig) {
LDKChannelCounterparty orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelCounterparty ret_var = ChannelCounterparty_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelDetails this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelDetails_free(this_obj_conv);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *ChannelDetails_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelCounterparty ret_var = ChannelDetails_get_counterparty(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelCounterparty val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelCounterparty_clone(&val_conv);
ChannelDetails_set_counterparty(&this_ptr_conv, val_conv);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint ret_var = ChannelDetails_get_funding_txo(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = OutPoint_clone(&val_conv);
ChannelDetails_set_funding_txo(&this_ptr_conv, val_conv);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = ChannelDetails_get_short_channel_id(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelDetails_get_channel_value_satoshis(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_channel_value_satoshis(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = ChannelDetails_get_unspendable_punishment_reserve(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelDetails_get_user_channel_id(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_user_channel_id(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelDetails_get_outbound_capacity_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_outbound_capacity_msat(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelDetails_get_inbound_capacity_msat(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_inbound_capacity_msat(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
*ret_copy = ChannelDetails_get_confirmations_required(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
*ret_copy = ChannelDetails_get_force_close_spend_delay(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u16Z val_conv = *(LDKCOption_u16Z*)(val_ptr);
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelDetails_get_is_outbound(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_is_outbound(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelDetails_get_is_funding_locked(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_is_funding_locked(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelDetails_get_is_usable(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_is_usable(&this_ptr_conv, val);
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelDetails_get_is_public(&this_ptr_conv);
return ret_val;
}
LDKChannelDetails this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelDetails_set_is_public(&this_ptr_conv, val);
}
LDKChannelCounterparty counterparty_arg_conv;
counterparty_arg_conv.inner = (void*)(counterparty_arg & (~1));
counterparty_arg_conv.is_owned = (counterparty_arg & 1) || (counterparty_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(counterparty_arg_conv);
counterparty_arg_conv = ChannelCounterparty_clone(&counterparty_arg_conv);
LDKOutPoint funding_txo_arg_conv;
funding_txo_arg_conv.inner = (void*)(funding_txo_arg & (~1));
funding_txo_arg_conv.is_owned = (funding_txo_arg & 1) || (funding_txo_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_arg_conv);
funding_txo_arg_conv = OutPoint_clone(&funding_txo_arg_conv);
void* short_channel_id_arg_ptr = (void*)(((uint64_t)short_channel_id_arg) & ~1);
CHECK_ACCESS(short_channel_id_arg_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg) {
+ LDKChannelDetails ret_var = ChannelDetails_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelDetails_clone_ptr(uint32_t arg) {
+ LDKChannelDetails arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelDetails_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelDetails_clone(uint32_t orig) {
LDKChannelDetails orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelDetails ret_var = ChannelDetails_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
PaymentSendFailure_free(this_ptr_conv);
}
+static inline uint64_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg) {
+ LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
+ *ret_copy = PaymentSendFailure_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_PaymentSendFailure_clone_ptr(uint32_t arg) {
+ LDKPaymentSendFailure* arg_conv = (LDKPaymentSendFailure*)arg;
+ int64_t ret_val = PaymentSendFailure_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_PaymentSendFailure_clone(uint32_t orig) {
LDKPaymentSendFailure* orig_conv = (LDKPaymentSendFailure*)orig;
LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
LDKRouteParameters failed_paths_retry_conv;
failed_paths_retry_conv.inner = (void*)(failed_paths_retry & (~1));
failed_paths_retry_conv.is_owned = (failed_paths_retry & 1) || (failed_paths_retry == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(failed_paths_retry_conv);
failed_paths_retry_conv = RouteParameters_clone(&failed_paths_retry_conv);
LDKThirtyTwoBytes payment_id_ref;
CHECK(*((uint32_t*)payment_id) == 32);
LDKUserConfig config_conv;
config_conv.inner = (void*)(config & (~1));
config_conv.is_owned = (config & 1) || (config == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(config_conv);
config_conv = UserConfig_clone(&config_conv);
LDKChainParameters params_conv;
params_conv.inner = (void*)(params & (~1));
params_conv.is_owned = (params & 1) || (params == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
params_conv = ChainParameters_clone(¶ms_conv);
LDKChannelManager ret_var = ChannelManager_new(fee_est_conv, chain_monitor_conv, tx_broadcaster_conv, logger_conv, keys_manager_conv, config_conv, params_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKUserConfig ret_var = ChannelManager_get_current_default_configuration(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPublicKey their_network_key_ref;
CHECK(*((uint32_t*)their_network_key) == 33);
memcpy(their_network_key_ref.compressed_form, (uint8_t*)(their_network_key + 4), 33);
LDKUserConfig override_config_conv;
override_config_conv.inner = (void*)(override_config & (~1));
override_config_conv.is_owned = (override_config & 1) || (override_config == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(override_config_conv);
override_config_conv = UserConfig_clone(&override_config_conv);
LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
*ret_conv = ChannelManager_create_channel(&this_arg_conv, their_network_key_ref, channel_value_satoshis, push_msat, user_channel_id, override_config_conv);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_channels(&this_arg_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_16_ref = 0;
CHECK((((uint64_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
ret_conv_16_ref = (uint64_t)ret_conv_16_var.inner;
if (ret_conv_16_var.is_owned) {
ret_conv_16_ref |= 1;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_usable_channels(&this_arg_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_16_ref = 0;
CHECK((((uint64_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
ret_conv_16_ref = (uint64_t)ret_conv_16_var.inner;
if (ret_conv_16_var.is_owned) {
ret_conv_16_ref |= 1;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char channel_id_arr[32];
CHECK(*((uint32_t*)channel_id) == 32);
memcpy(channel_id_arr, (uint8_t*)(channel_id + 4), 32);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char channel_id_arr[32];
CHECK(*((uint32_t*)channel_id) == 32);
memcpy(channel_id_arr, (uint8_t*)(channel_id + 4), 32);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char channel_id_arr[32];
CHECK(*((uint32_t*)channel_id) == 32);
memcpy(channel_id_arr, (uint8_t*)(channel_id + 4), 32);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
ChannelManager_force_close_all_channels(&this_arg_conv);
}
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRoute route_conv;
route_conv.inner = (void*)(route & (~1));
route_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
LDKThirtyTwoBytes payment_hash_ref;
CHECK(*((uint32_t*)payment_hash) == 32);
memcpy(payment_hash_ref.data, (uint8_t*)(payment_hash + 4), 32);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRoute route_conv;
route_conv.inner = (void*)(route & (~1));
route_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
LDKThirtyTwoBytes payment_id_ref;
CHECK(*((uint32_t*)payment_id) == 32);
memcpy(payment_id_ref.data, (uint8_t*)(payment_id + 4), 32);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRoute route_conv;
route_conv.inner = (void*)(route & (~1));
route_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
LDKThirtyTwoBytes payment_preimage_ref;
CHECK(*((uint32_t*)payment_preimage) == 32);
memcpy(payment_preimage_ref.data, (uint8_t*)(payment_preimage + 4), 32);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char temporary_channel_id_arr[32];
CHECK(*((uint32_t*)temporary_channel_id) == 32);
memcpy(temporary_channel_id_arr, (uint8_t*)(temporary_channel_id + 4), 32);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKThreeBytes rgb_ref;
CHECK(*((uint32_t*)rgb) == 3);
memcpy(rgb_ref.data, (uint8_t*)(rgb + 4), 3);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
ChannelManager_process_pending_htlc_forwards(&this_arg_conv);
}
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
ChannelManager_timer_tick_occurred(&this_arg_conv);
}
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char payment_hash_arr[32];
CHECK(*((uint32_t*)payment_hash) == 32);
memcpy(payment_hash_arr, (uint8_t*)(payment_hash + 4), 32);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKThirtyTwoBytes payment_preimage_ref;
CHECK(*((uint32_t*)payment_preimage) == 32);
memcpy(payment_preimage_ref.data, (uint8_t*)(payment_preimage + 4), 32);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelManager_get_our_node_id(&this_arg_conv).compressed_form, 33);
return ret_arr;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* min_value_msat_ptr = (void*)(((uint64_t)min_value_msat) & ~1);
CHECK_ACCESS(min_value_msat_ptr);
LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKThirtyTwoBytes payment_hash_ref;
CHECK(*((uint32_t*)payment_hash) == 32);
memcpy(payment_hash_ref.data, (uint8_t*)(payment_hash + 4), 32);
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
*ret_ret = ChannelManager_as_MessageSendEventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKEventsProvider* ret_ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
*ret_ret = ChannelManager_as_EventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKListen* ret_ret = MALLOC(sizeof(LDKListen), "LDKListen");
*ret_ret = ChannelManager_as_Listen(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKConfirm* ret_ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
*ret_ret = ChannelManager_as_Confirm(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = ChannelManager_await_persistable_update_timeout(&this_arg_conv, max_wait);
return ret_val;
}
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
ChannelManager_await_persistable_update(&this_arg_conv);
}
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKBestBlock ret_var = ChannelManager_current_best_block(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelMessageHandler* ret_ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
*ret_ret = ChannelManager_as_ChannelMessageHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelManager_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKChannelManagerReadArgs this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelManagerReadArgs_free(this_obj_conv);
}
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)ChannelManagerReadArgs_get_keys_manager(&this_ptr_conv)) | 1;
return ret_ret;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKKeysInterface val_conv = *(LDKKeysInterface*)(val_ptr);
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)ChannelManagerReadArgs_get_fee_estimator(&this_ptr_conv)) | 1;
return ret_ret;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKFeeEstimator val_conv = *(LDKFeeEstimator*)(val_ptr);
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)ChannelManagerReadArgs_get_chain_monitor(&this_ptr_conv)) | 1;
return ret_ret;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKWatch val_conv = *(LDKWatch*)(val_ptr);
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)ChannelManagerReadArgs_get_tx_broadcaster(&this_ptr_conv)) | 1;
return ret_ret;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKBroadcasterInterface val_conv = *(LDKBroadcasterInterface*)(val_ptr);
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)ChannelManagerReadArgs_get_logger(&this_ptr_conv)) | 1;
return ret_ret;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKLogger val_conv = *(LDKLogger*)(val_ptr);
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUserConfig ret_var = ChannelManagerReadArgs_get_default_config(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelManagerReadArgs this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUserConfig val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = UserConfig_clone(&val_conv);
ChannelManagerReadArgs_set_default_config(&this_ptr_conv, val_conv);
}
LDKUserConfig default_config_conv;
default_config_conv.inner = (void*)(default_config & (~1));
default_config_conv.is_owned = (default_config & 1) || (default_config == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(default_config_conv);
default_config_conv = UserConfig_clone(&default_config_conv);
LDKCVec_ChannelMonitorZ channel_monitors_constr;
channel_monitors_constr.datalen = *((uint32_t*)channel_monitors);
LDKChannelMonitor channel_monitors_conv_16_conv;
channel_monitors_conv_16_conv.inner = (void*)(channel_monitors_conv_16 & (~1));
channel_monitors_conv_16_conv.is_owned = (channel_monitors_conv_16 & 1) || (channel_monitors_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_monitors_conv_16_conv);
channel_monitors_constr.data[q] = channel_monitors_conv_16_conv;
}
LDKChannelManagerReadArgs ret_var = ChannelManagerReadArgs_new(keys_manager_conv, fee_estimator_conv, chain_monitor_conv, tx_broadcaster_conv, logger_conv, default_config_conv, channel_monitors_constr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelManagerReadArgs arg_conv;
arg_conv.inner = (void*)(arg & (~1));
arg_conv.is_owned = (arg & 1) || (arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
// Warning: we need a move here but no clone is available for LDKChannelManagerReadArgs
LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
*ret_conv = C2Tuple_BlockHashChannelManagerZ_read(ser_ref, arg_conv);
LDKDecodeError this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DecodeError_free(this_obj_conv);
}
+static inline uint64_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg) {
+ LDKDecodeError ret_var = DecodeError_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_DecodeError_clone_ptr(uint32_t arg) {
+ LDKDecodeError arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = DecodeError_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_DecodeError_clone(uint32_t orig) {
LDKDecodeError orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKDecodeError ret_var = DecodeError_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInit this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Init_free(this_obj_conv);
}
LDKInit this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInitFeatures ret_var = Init_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInit this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInitFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = InitFeatures_clone(&val_conv);
Init_set_features(&this_ptr_conv, val_conv);
}
LDKInitFeatures features_arg_conv;
features_arg_conv.inner = (void*)(features_arg & (~1));
features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
features_arg_conv = InitFeatures_clone(&features_arg_conv);
LDKInit ret_var = Init_new(features_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Init_clone_ptr(LDKInit *NONNULL_PTR arg) {
+ LDKInit ret_var = Init_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Init_clone_ptr(uint32_t arg) {
+ LDKInit arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Init_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Init_clone(uint32_t orig) {
LDKInit orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInit ret_var = Init_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKErrorMessage this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ErrorMessage_free(this_obj_conv);
}
LDKErrorMessage this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *ErrorMessage_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKErrorMessage this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKErrorMessage this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr ret_str = ErrorMessage_get_data(&this_ptr_conv);
jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
Str_free(ret_str);
LDKErrorMessage this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr val_conv = str_ref_to_owned_c(val);
ErrorMessage_set_data(&this_ptr_conv, val_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg) {
+ LDKErrorMessage ret_var = ErrorMessage_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ErrorMessage_clone_ptr(uint32_t arg) {
+ LDKErrorMessage arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ErrorMessage_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ErrorMessage_clone(uint32_t orig) {
LDKErrorMessage orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKErrorMessage ret_var = ErrorMessage_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPing this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Ping_free(this_obj_conv);
}
LDKPing this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = Ping_get_ponglen(&this_ptr_conv);
return ret_val;
}
LDKPing this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
Ping_set_ponglen(&this_ptr_conv, val);
}
LDKPing this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = Ping_get_byteslen(&this_ptr_conv);
return ret_val;
}
LDKPing this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
Ping_set_byteslen(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg) {
+ LDKPing ret_var = Ping_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Ping_clone_ptr(uint32_t arg) {
+ LDKPing arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Ping_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Ping_clone(uint32_t orig) {
LDKPing orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPing ret_var = Ping_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPong this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Pong_free(this_obj_conv);
}
LDKPong this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = Pong_get_byteslen(&this_ptr_conv);
return ret_val;
}
LDKPong this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
Pong_set_byteslen(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg) {
+ LDKPong ret_var = Pong_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Pong_clone_ptr(uint32_t arg) {
+ LDKPong arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Pong_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Pong_clone(uint32_t orig) {
LDKPong orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPong ret_var = Pong_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKOpenChannel this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
OpenChannel_free(this_obj_conv);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *OpenChannel_get_chain_hash(&this_ptr_conv), 32);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *OpenChannel_get_temporary_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_funding_satoshis(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_funding_satoshis(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_push_msat(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_push_msat(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_dust_limit_satoshis(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_channel_reserve_satoshis(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = OpenChannel_get_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = OpenChannel_get_feerate_per_kw(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_feerate_per_kw(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = OpenChannel_get_to_self_delay(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_to_self_delay(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = OpenChannel_get_max_accepted_htlcs(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), OpenChannel_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), OpenChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), OpenChannel_get_payment_point(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), OpenChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), OpenChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), OpenChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_t ret_val = OpenChannel_get_channel_flags(&this_ptr_conv);
return ret_val;
}
LDKOpenChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
OpenChannel_set_channel_flags(&this_ptr_conv, val);
}
+static inline uint64_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg) {
+ LDKOpenChannel ret_var = OpenChannel_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_OpenChannel_clone_ptr(uint32_t arg) {
+ LDKOpenChannel arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = OpenChannel_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_OpenChannel_clone(uint32_t orig) {
LDKOpenChannel orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKOpenChannel ret_var = OpenChannel_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKAcceptChannel this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
AcceptChannel_free(this_obj_conv);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *AcceptChannel_get_temporary_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = AcceptChannel_get_dust_limit_satoshis(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = AcceptChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = AcceptChannel_get_channel_reserve_satoshis(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = AcceptChannel_get_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = AcceptChannel_get_minimum_depth(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_minimum_depth(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = AcceptChannel_get_to_self_delay(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_to_self_delay(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = AcceptChannel_get_max_accepted_htlcs(&this_ptr_conv);
return ret_val;
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AcceptChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
}
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), AcceptChannel_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), AcceptChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), AcceptChannel_get_payment_point(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), AcceptChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), AcceptChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), AcceptChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKAcceptChannel this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
AcceptChannel_set_first_per_commitment_point(&this_ptr_conv, val_ref);
}
+static inline uint64_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg) {
+ LDKAcceptChannel ret_var = AcceptChannel_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_AcceptChannel_clone_ptr(uint32_t arg) {
+ LDKAcceptChannel arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = AcceptChannel_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_AcceptChannel_clone(uint32_t orig) {
LDKAcceptChannel orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKAcceptChannel ret_var = AcceptChannel_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKFundingCreated this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
FundingCreated_free(this_obj_conv);
}
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *FundingCreated_get_temporary_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *FundingCreated_get_funding_txid(&this_ptr_conv), 32);
return ret_arr;
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = FundingCreated_get_funding_output_index(&this_ptr_conv);
return ret_val;
}
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
FundingCreated_set_funding_output_index(&this_ptr_conv, val);
}
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), FundingCreated_get_signature(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKFundingCreated this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg) {
+ LDKFundingCreated ret_var = FundingCreated_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_FundingCreated_clone_ptr(uint32_t arg) {
+ LDKFundingCreated arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = FundingCreated_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_FundingCreated_clone(uint32_t orig) {
LDKFundingCreated orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKFundingCreated ret_var = FundingCreated_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKFundingSigned this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
FundingSigned_free(this_obj_conv);
}
LDKFundingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *FundingSigned_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKFundingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKFundingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), FundingSigned_get_signature(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKFundingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg) {
+ LDKFundingSigned ret_var = FundingSigned_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_FundingSigned_clone_ptr(uint32_t arg) {
+ LDKFundingSigned arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = FundingSigned_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_FundingSigned_clone(uint32_t orig) {
LDKFundingSigned orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKFundingSigned ret_var = FundingSigned_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKFundingLocked this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
FundingLocked_free(this_obj_conv);
}
LDKFundingLocked this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *FundingLocked_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKFundingLocked this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKFundingLocked this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), FundingLocked_get_next_per_commitment_point(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKFundingLocked this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t FundingLocked_clone_ptr(LDKFundingLocked *NONNULL_PTR arg) {
+ LDKFundingLocked ret_var = FundingLocked_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_FundingLocked_clone_ptr(uint32_t arg) {
+ LDKFundingLocked arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = FundingLocked_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_FundingLocked_clone(uint32_t orig) {
LDKFundingLocked orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKFundingLocked ret_var = FundingLocked_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKShutdown this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Shutdown_free(this_obj_conv);
}
LDKShutdown this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *Shutdown_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKShutdown this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKShutdown this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKu8slice ret_var = Shutdown_get_scriptpubkey(&this_ptr_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKShutdown this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u8Z val_ref;
val_ref.datalen = *((uint32_t*)val);
val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg) {
+ LDKShutdown ret_var = Shutdown_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Shutdown_clone_ptr(uint32_t arg) {
+ LDKShutdown arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Shutdown_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Shutdown_clone(uint32_t orig) {
LDKShutdown orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKShutdown ret_var = Shutdown_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingSignedFeeRange this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ClosingSignedFeeRange_free(this_obj_conv);
}
LDKClosingSignedFeeRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ClosingSignedFeeRange_get_min_fee_satoshis(&this_ptr_conv);
return ret_val;
}
LDKClosingSignedFeeRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ClosingSignedFeeRange_set_min_fee_satoshis(&this_ptr_conv, val);
}
LDKClosingSignedFeeRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ClosingSignedFeeRange_get_max_fee_satoshis(&this_ptr_conv);
return ret_val;
}
LDKClosingSignedFeeRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ClosingSignedFeeRange_set_max_fee_satoshis(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg) {
+ LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ClosingSignedFeeRange_clone_ptr(uint32_t arg) {
+ LDKClosingSignedFeeRange arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ClosingSignedFeeRange_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ClosingSignedFeeRange_clone(uint32_t orig) {
LDKClosingSignedFeeRange orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingSigned this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ClosingSigned_free(this_obj_conv);
}
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *ClosingSigned_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ClosingSigned_get_fee_satoshis(&this_ptr_conv);
return ret_val;
}
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ClosingSigned_set_fee_satoshis(&this_ptr_conv, val);
}
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ClosingSigned_get_signature(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKClosingSignedFeeRange ret_var = ClosingSigned_get_fee_range(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKClosingSignedFeeRange val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ClosingSignedFeeRange_clone(&val_conv);
ClosingSigned_set_fee_range(&this_ptr_conv, val_conv);
}
LDKClosingSignedFeeRange fee_range_arg_conv;
fee_range_arg_conv.inner = (void*)(fee_range_arg & (~1));
fee_range_arg_conv.is_owned = (fee_range_arg & 1) || (fee_range_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(fee_range_arg_conv);
fee_range_arg_conv = ClosingSignedFeeRange_clone(&fee_range_arg_conv);
LDKClosingSigned ret_var = ClosingSigned_new(channel_id_arg_ref, fee_satoshis_arg, signature_arg_ref, fee_range_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg) {
+ LDKClosingSigned ret_var = ClosingSigned_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ClosingSigned_clone_ptr(uint32_t arg) {
+ LDKClosingSigned arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ClosingSigned_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ClosingSigned_clone(uint32_t orig) {
LDKClosingSigned orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKClosingSigned ret_var = ClosingSigned_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUpdateAddHTLC this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UpdateAddHTLC_free(this_obj_conv);
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *UpdateAddHTLC_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UpdateAddHTLC_get_htlc_id(&this_ptr_conv);
return ret_val;
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateAddHTLC_set_htlc_id(&this_ptr_conv, val);
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UpdateAddHTLC_get_amount_msat(&this_ptr_conv);
return ret_val;
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateAddHTLC_set_amount_msat(&this_ptr_conv, val);
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *UpdateAddHTLC_get_payment_hash(&this_ptr_conv), 32);
return ret_arr;
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UpdateAddHTLC_get_cltv_expiry(&this_ptr_conv);
return ret_val;
}
LDKUpdateAddHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateAddHTLC_set_cltv_expiry(&this_ptr_conv, val);
}
+static inline uint64_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg) {
+ LDKUpdateAddHTLC ret_var = UpdateAddHTLC_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_UpdateAddHTLC_clone_ptr(uint32_t arg) {
+ LDKUpdateAddHTLC arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UpdateAddHTLC_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_UpdateAddHTLC_clone(uint32_t orig) {
LDKUpdateAddHTLC orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUpdateAddHTLC ret_var = UpdateAddHTLC_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUpdateFulfillHTLC this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UpdateFulfillHTLC_free(this_obj_conv);
}
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *UpdateFulfillHTLC_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UpdateFulfillHTLC_get_htlc_id(&this_ptr_conv);
return ret_val;
}
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateFulfillHTLC_set_htlc_id(&this_ptr_conv, val);
}
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *UpdateFulfillHTLC_get_payment_preimage(&this_ptr_conv), 32);
return ret_arr;
LDKUpdateFulfillHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg) {
+ LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_UpdateFulfillHTLC_clone_ptr(uint32_t arg) {
+ LDKUpdateFulfillHTLC arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UpdateFulfillHTLC_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_UpdateFulfillHTLC_clone(uint32_t orig) {
LDKUpdateFulfillHTLC orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUpdateFailHTLC this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UpdateFailHTLC_free(this_obj_conv);
}
LDKUpdateFailHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *UpdateFailHTLC_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKUpdateFailHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKUpdateFailHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UpdateFailHTLC_get_htlc_id(&this_ptr_conv);
return ret_val;
}
LDKUpdateFailHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateFailHTLC_set_htlc_id(&this_ptr_conv, val);
}
+static inline uint64_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg) {
+ LDKUpdateFailHTLC ret_var = UpdateFailHTLC_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_UpdateFailHTLC_clone_ptr(uint32_t arg) {
+ LDKUpdateFailHTLC arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UpdateFailHTLC_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_UpdateFailHTLC_clone(uint32_t orig) {
LDKUpdateFailHTLC orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUpdateFailHTLC ret_var = UpdateFailHTLC_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUpdateFailMalformedHTLC this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UpdateFailMalformedHTLC_free(this_obj_conv);
}
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *UpdateFailMalformedHTLC_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UpdateFailMalformedHTLC_get_htlc_id(&this_ptr_conv);
return ret_val;
}
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateFailMalformedHTLC_set_htlc_id(&this_ptr_conv, val);
}
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = UpdateFailMalformedHTLC_get_failure_code(&this_ptr_conv);
return ret_val;
}
LDKUpdateFailMalformedHTLC this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateFailMalformedHTLC_set_failure_code(&this_ptr_conv, val);
}
+static inline uint64_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg) {
+ LDKUpdateFailMalformedHTLC ret_var = UpdateFailMalformedHTLC_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_UpdateFailMalformedHTLC_clone_ptr(uint32_t arg) {
+ LDKUpdateFailMalformedHTLC arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UpdateFailMalformedHTLC_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_UpdateFailMalformedHTLC_clone(uint32_t orig) {
LDKUpdateFailMalformedHTLC orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUpdateFailMalformedHTLC ret_var = UpdateFailMalformedHTLC_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentSigned this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
CommitmentSigned_free(this_obj_conv);
}
LDKCommitmentSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *CommitmentSigned_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKCommitmentSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKCommitmentSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), CommitmentSigned_get_signature(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKCommitmentSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
LDKCommitmentSigned this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_SignatureZ val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg) {
+ LDKCommitmentSigned ret_var = CommitmentSigned_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_CommitmentSigned_clone_ptr(uint32_t arg) {
+ LDKCommitmentSigned arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = CommitmentSigned_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CommitmentSigned_clone(uint32_t orig) {
LDKCommitmentSigned orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKCommitmentSigned ret_var = CommitmentSigned_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRevokeAndACK this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RevokeAndACK_free(this_obj_conv);
}
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *RevokeAndACK_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *RevokeAndACK_get_per_commitment_secret(&this_ptr_conv), 32);
return ret_arr;
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), RevokeAndACK_get_next_per_commitment_point(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKRevokeAndACK this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg) {
+ LDKRevokeAndACK ret_var = RevokeAndACK_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_RevokeAndACK_clone_ptr(uint32_t arg) {
+ LDKRevokeAndACK arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RevokeAndACK_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_RevokeAndACK_clone(uint32_t orig) {
LDKRevokeAndACK orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRevokeAndACK ret_var = RevokeAndACK_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUpdateFee this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UpdateFee_free(this_obj_conv);
}
LDKUpdateFee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *UpdateFee_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKUpdateFee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKUpdateFee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UpdateFee_get_feerate_per_kw(&this_ptr_conv);
return ret_val;
}
LDKUpdateFee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UpdateFee_set_feerate_per_kw(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg) {
+ LDKUpdateFee ret_var = UpdateFee_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_UpdateFee_clone_ptr(uint32_t arg) {
+ LDKUpdateFee arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UpdateFee_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_UpdateFee_clone(uint32_t orig) {
LDKUpdateFee orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUpdateFee ret_var = UpdateFee_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDataLossProtect this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DataLossProtect_free(this_obj_conv);
}
LDKDataLossProtect this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *DataLossProtect_get_your_last_per_commitment_secret(&this_ptr_conv), 32);
return ret_arr;
LDKDataLossProtect this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKDataLossProtect this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), DataLossProtect_get_my_current_per_commitment_point(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKDataLossProtect this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg) {
+ LDKDataLossProtect ret_var = DataLossProtect_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_DataLossProtect_clone_ptr(uint32_t arg) {
+ LDKDataLossProtect arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = DataLossProtect_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_DataLossProtect_clone(uint32_t orig) {
LDKDataLossProtect orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKDataLossProtect ret_var = DataLossProtect_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelReestablish this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelReestablish_free(this_obj_conv);
}
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *ChannelReestablish_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelReestablish_get_next_local_commitment_number(&this_ptr_conv);
return ret_val;
}
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelReestablish_set_next_local_commitment_number(&this_ptr_conv, val);
}
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ChannelReestablish_get_next_remote_commitment_number(&this_ptr_conv);
return ret_val;
}
LDKChannelReestablish this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelReestablish_set_next_remote_commitment_number(&this_ptr_conv, val);
}
+static inline uint64_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg) {
+ LDKChannelReestablish ret_var = ChannelReestablish_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelReestablish_clone_ptr(uint32_t arg) {
+ LDKChannelReestablish arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelReestablish_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelReestablish_clone(uint32_t orig) {
LDKChannelReestablish orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelReestablish ret_var = ChannelReestablish_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKAnnouncementSignatures this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
AnnouncementSignatures_free(this_obj_conv);
}
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *AnnouncementSignatures_get_channel_id(&this_ptr_conv), 32);
return ret_arr;
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = AnnouncementSignatures_get_short_channel_id(&this_ptr_conv);
return ret_val;
}
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
AnnouncementSignatures_set_short_channel_id(&this_ptr_conv, val);
}
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), AnnouncementSignatures_get_node_signature(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), AnnouncementSignatures_get_bitcoin_signature(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKAnnouncementSignatures this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg) {
+ LDKAnnouncementSignatures ret_var = AnnouncementSignatures_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_AnnouncementSignatures_clone_ptr(uint32_t arg) {
+ LDKAnnouncementSignatures arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = AnnouncementSignatures_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_AnnouncementSignatures_clone(uint32_t orig) {
LDKAnnouncementSignatures orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKAnnouncementSignatures ret_var = AnnouncementSignatures_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
NetAddress_free(this_ptr_conv);
}
+static inline uint64_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg) {
+ LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
+ *ret_copy = NetAddress_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_NetAddress_clone_ptr(uint32_t arg) {
+ LDKNetAddress* arg_conv = (LDKNetAddress*)arg;
+ int64_t ret_val = NetAddress_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_NetAddress_clone(uint32_t orig) {
LDKNetAddress* orig_conv = (LDKNetAddress*)orig;
LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
LDKUnsignedNodeAnnouncement this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UnsignedNodeAnnouncement_free(this_obj_conv);
}
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures ret_var = UnsignedNodeAnnouncement_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeFeatures_clone(&val_conv);
UnsignedNodeAnnouncement_set_features(&this_ptr_conv, val_conv);
}
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UnsignedNodeAnnouncement_get_timestamp(&this_ptr_conv);
return ret_val;
}
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedNodeAnnouncement_set_timestamp(&this_ptr_conv, val);
}
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), UnsignedNodeAnnouncement_get_node_id(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(3, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *UnsignedNodeAnnouncement_get_rgb(&this_ptr_conv), 3);
return ret_arr;
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThreeBytes val_ref;
CHECK(*((uint32_t*)val) == 3);
memcpy(val_ref.data, (uint8_t*)(val + 4), 3);
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *UnsignedNodeAnnouncement_get_alias(&this_ptr_conv), 32);
return ret_arr;
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKUnsignedNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_NetAddressZ val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
UnsignedNodeAnnouncement_set_addresses(&this_ptr_conv, val_constr);
}
+static inline uint64_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg) {
+ LDKUnsignedNodeAnnouncement ret_var = UnsignedNodeAnnouncement_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_UnsignedNodeAnnouncement_clone_ptr(uint32_t arg) {
+ LDKUnsignedNodeAnnouncement arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UnsignedNodeAnnouncement_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_UnsignedNodeAnnouncement_clone(uint32_t orig) {
LDKUnsignedNodeAnnouncement orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUnsignedNodeAnnouncement ret_var = UnsignedNodeAnnouncement_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeAnnouncement this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NodeAnnouncement_free(this_obj_conv);
}
LDKNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), NodeAnnouncement_get_signature(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
LDKNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedNodeAnnouncement ret_var = NodeAnnouncement_get_contents(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedNodeAnnouncement val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = UnsignedNodeAnnouncement_clone(&val_conv);
NodeAnnouncement_set_contents(&this_ptr_conv, val_conv);
}
LDKUnsignedNodeAnnouncement contents_arg_conv;
contents_arg_conv.inner = (void*)(contents_arg & (~1));
contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
contents_arg_conv = UnsignedNodeAnnouncement_clone(&contents_arg_conv);
LDKNodeAnnouncement ret_var = NodeAnnouncement_new(signature_arg_ref, contents_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg) {
+ LDKNodeAnnouncement ret_var = NodeAnnouncement_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_NodeAnnouncement_clone_ptr(uint32_t arg) {
+ LDKNodeAnnouncement arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NodeAnnouncement_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncement_clone(uint32_t orig) {
LDKNodeAnnouncement orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNodeAnnouncement ret_var = NodeAnnouncement_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUnsignedChannelAnnouncement this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UnsignedChannelAnnouncement_free(this_obj_conv);
}
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures ret_var = UnsignedChannelAnnouncement_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelFeatures_clone(&val_conv);
UnsignedChannelAnnouncement_set_features(&this_ptr_conv, val_conv);
}
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *UnsignedChannelAnnouncement_get_chain_hash(&this_ptr_conv), 32);
return ret_arr;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UnsignedChannelAnnouncement_get_short_channel_id(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelAnnouncement_set_short_channel_id(&this_ptr_conv, val);
}
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), UnsignedChannelAnnouncement_get_node_id_1(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), UnsignedChannelAnnouncement_get_node_id_2(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), UnsignedChannelAnnouncement_get_bitcoin_key_1(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), UnsignedChannelAnnouncement_get_bitcoin_key_2(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKUnsignedChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
UnsignedChannelAnnouncement_set_bitcoin_key_2(&this_ptr_conv, val_ref);
}
+static inline uint64_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg) {
+ LDKUnsignedChannelAnnouncement ret_var = UnsignedChannelAnnouncement_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_UnsignedChannelAnnouncement_clone_ptr(uint32_t arg) {
+ LDKUnsignedChannelAnnouncement arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UnsignedChannelAnnouncement_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_UnsignedChannelAnnouncement_clone(uint32_t orig) {
LDKUnsignedChannelAnnouncement orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUnsignedChannelAnnouncement ret_var = UnsignedChannelAnnouncement_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelAnnouncement this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelAnnouncement_free(this_obj_conv);
}
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelAnnouncement_get_node_signature_1(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelAnnouncement_get_node_signature_2(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelAnnouncement_get_bitcoin_signature_1(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelAnnouncement_get_bitcoin_signature_2(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedChannelAnnouncement ret_var = ChannelAnnouncement_get_contents(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelAnnouncement this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedChannelAnnouncement val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = UnsignedChannelAnnouncement_clone(&val_conv);
ChannelAnnouncement_set_contents(&this_ptr_conv, val_conv);
}
LDKUnsignedChannelAnnouncement contents_arg_conv;
contents_arg_conv.inner = (void*)(contents_arg & (~1));
contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
contents_arg_conv = UnsignedChannelAnnouncement_clone(&contents_arg_conv);
LDKChannelAnnouncement ret_var = ChannelAnnouncement_new(node_signature_1_arg_ref, node_signature_2_arg_ref, bitcoin_signature_1_arg_ref, bitcoin_signature_2_arg_ref, contents_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg) {
+ LDKChannelAnnouncement ret_var = ChannelAnnouncement_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelAnnouncement_clone_ptr(uint32_t arg) {
+ LDKChannelAnnouncement arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelAnnouncement_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelAnnouncement_clone(uint32_t orig) {
LDKChannelAnnouncement orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelAnnouncement ret_var = ChannelAnnouncement_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKUnsignedChannelUpdate this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
UnsignedChannelUpdate_free(this_obj_conv);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *UnsignedChannelUpdate_get_chain_hash(&this_ptr_conv), 32);
return ret_arr;
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UnsignedChannelUpdate_get_short_channel_id(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_short_channel_id(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UnsignedChannelUpdate_get_timestamp(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_timestamp(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_t ret_val = UnsignedChannelUpdate_get_flags(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_flags(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = UnsignedChannelUpdate_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = UnsignedChannelUpdate_get_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_htlc_minimum_msat(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UnsignedChannelUpdate_get_fee_base_msat(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_fee_base_msat(&this_ptr_conv, val);
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = UnsignedChannelUpdate_get_fee_proportional_millionths(&this_ptr_conv);
return ret_val;
}
LDKUnsignedChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
UnsignedChannelUpdate_set_fee_proportional_millionths(&this_ptr_conv, val);
}
+static inline uint64_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg) {
+ LDKUnsignedChannelUpdate ret_var = UnsignedChannelUpdate_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_clone_ptr(uint32_t arg) {
+ LDKUnsignedChannelUpdate arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = UnsignedChannelUpdate_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_clone(uint32_t orig) {
LDKUnsignedChannelUpdate orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKUnsignedChannelUpdate ret_var = UnsignedChannelUpdate_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelUpdate this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelUpdate_free(this_obj_conv);
}
LDKChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelUpdate_get_signature(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
LDKChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedChannelUpdate ret_var = ChannelUpdate_get_contents(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUnsignedChannelUpdate val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = UnsignedChannelUpdate_clone(&val_conv);
ChannelUpdate_set_contents(&this_ptr_conv, val_conv);
}
LDKUnsignedChannelUpdate contents_arg_conv;
contents_arg_conv.inner = (void*)(contents_arg & (~1));
contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
contents_arg_conv = UnsignedChannelUpdate_clone(&contents_arg_conv);
LDKChannelUpdate ret_var = ChannelUpdate_new(signature_arg_ref, contents_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg) {
+ LDKChannelUpdate ret_var = ChannelUpdate_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelUpdate_clone_ptr(uint32_t arg) {
+ LDKChannelUpdate arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelUpdate_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelUpdate_clone(uint32_t orig) {
LDKChannelUpdate orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelUpdate ret_var = ChannelUpdate_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKQueryChannelRange this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
QueryChannelRange_free(this_obj_conv);
}
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *QueryChannelRange_get_chain_hash(&this_ptr_conv), 32);
return ret_arr;
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = QueryChannelRange_get_first_blocknum(&this_ptr_conv);
return ret_val;
}
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
QueryChannelRange_set_first_blocknum(&this_ptr_conv, val);
}
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = QueryChannelRange_get_number_of_blocks(&this_ptr_conv);
return ret_val;
}
LDKQueryChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
QueryChannelRange_set_number_of_blocks(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg) {
+ LDKQueryChannelRange ret_var = QueryChannelRange_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_QueryChannelRange_clone_ptr(uint32_t arg) {
+ LDKQueryChannelRange arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = QueryChannelRange_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_QueryChannelRange_clone(uint32_t orig) {
LDKQueryChannelRange orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKQueryChannelRange ret_var = QueryChannelRange_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKReplyChannelRange this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ReplyChannelRange_free(this_obj_conv);
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *ReplyChannelRange_get_chain_hash(&this_ptr_conv), 32);
return ret_arr;
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ReplyChannelRange_get_first_blocknum(&this_ptr_conv);
return ret_val;
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ReplyChannelRange_set_first_blocknum(&this_ptr_conv, val);
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = ReplyChannelRange_get_number_of_blocks(&this_ptr_conv);
return ret_val;
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ReplyChannelRange_set_number_of_blocks(&this_ptr_conv, val);
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ReplyChannelRange_get_sync_complete(&this_ptr_conv);
return ret_val;
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ReplyChannelRange_set_sync_complete(&this_ptr_conv, val);
}
LDKReplyChannelRange this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u64Z val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg) {
+ LDKReplyChannelRange ret_var = ReplyChannelRange_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ReplyChannelRange_clone_ptr(uint32_t arg) {
+ LDKReplyChannelRange arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ReplyChannelRange_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ReplyChannelRange_clone(uint32_t orig) {
LDKReplyChannelRange orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKReplyChannelRange ret_var = ReplyChannelRange_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKQueryShortChannelIds this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
QueryShortChannelIds_free(this_obj_conv);
}
LDKQueryShortChannelIds this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *QueryShortChannelIds_get_chain_hash(&this_ptr_conv), 32);
return ret_arr;
LDKQueryShortChannelIds this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKQueryShortChannelIds this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u64Z val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg) {
+ LDKQueryShortChannelIds ret_var = QueryShortChannelIds_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_QueryShortChannelIds_clone_ptr(uint32_t arg) {
+ LDKQueryShortChannelIds arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = QueryShortChannelIds_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_QueryShortChannelIds_clone(uint32_t orig) {
LDKQueryShortChannelIds orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKQueryShortChannelIds ret_var = QueryShortChannelIds_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKReplyShortChannelIdsEnd this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ReplyShortChannelIdsEnd_free(this_obj_conv);
}
LDKReplyShortChannelIdsEnd this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *ReplyShortChannelIdsEnd_get_chain_hash(&this_ptr_conv), 32);
return ret_arr;
LDKReplyShortChannelIdsEnd this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKReplyShortChannelIdsEnd this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ReplyShortChannelIdsEnd_get_full_information(&this_ptr_conv);
return ret_val;
}
LDKReplyShortChannelIdsEnd this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ReplyShortChannelIdsEnd_set_full_information(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg) {
+ LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ReplyShortChannelIdsEnd_clone_ptr(uint32_t arg) {
+ LDKReplyShortChannelIdsEnd arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ReplyShortChannelIdsEnd_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ReplyShortChannelIdsEnd_clone(uint32_t orig) {
LDKReplyShortChannelIdsEnd orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKGossipTimestampFilter this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
GossipTimestampFilter_free(this_obj_conv);
}
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *GossipTimestampFilter_get_chain_hash(&this_ptr_conv), 32);
return ret_arr;
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = GossipTimestampFilter_get_first_timestamp(&this_ptr_conv);
return ret_val;
}
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
GossipTimestampFilter_set_first_timestamp(&this_ptr_conv, val);
}
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = GossipTimestampFilter_get_timestamp_range(&this_ptr_conv);
return ret_val;
}
LDKGossipTimestampFilter this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
GossipTimestampFilter_set_timestamp_range(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg) {
+ LDKGossipTimestampFilter ret_var = GossipTimestampFilter_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_GossipTimestampFilter_clone_ptr(uint32_t arg) {
+ LDKGossipTimestampFilter arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = GossipTimestampFilter_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_GossipTimestampFilter_clone(uint32_t orig) {
LDKGossipTimestampFilter orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKGossipTimestampFilter ret_var = GossipTimestampFilter_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
ErrorAction_free(this_ptr_conv);
}
+static inline uint64_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg) {
+ LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
+ *ret_copy = ErrorAction_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ErrorAction_clone_ptr(uint32_t arg) {
+ LDKErrorAction* arg_conv = (LDKErrorAction*)arg;
+ int64_t ret_val = ErrorAction_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ErrorAction_clone(uint32_t orig) {
LDKErrorAction* orig_conv = (LDKErrorAction*)orig;
LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
LDKErrorMessage msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ErrorMessage_clone(&msg_conv);
LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
*ret_copy = ErrorAction_disconnect_peer(msg_conv);
LDKErrorMessage msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ErrorMessage_clone(&msg_conv);
LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
*ret_copy = ErrorAction_send_error_message(msg_conv);
LDKLightningError this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
LightningError_free(this_obj_conv);
}
LDKLightningError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr ret_str = LightningError_get_err(&this_ptr_conv);
jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
Str_free(ret_str);
LDKLightningError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKStr val_conv = str_ref_to_owned_c(val);
LightningError_set_err(&this_ptr_conv, val_conv);
}
LDKLightningError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
*ret_copy = LightningError_get_action(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKLightningError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKErrorAction val_conv = *(LDKErrorAction*)(val_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg) {
+ LDKLightningError ret_var = LightningError_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_LightningError_clone_ptr(uint32_t arg) {
+ LDKLightningError arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = LightningError_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_LightningError_clone(uint32_t orig) {
LDKLightningError orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKLightningError ret_var = LightningError_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentUpdate this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
CommitmentUpdate_free(this_obj_conv);
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateAddHTLCZ ret_var = CommitmentUpdate_get_update_add_htlcs(&this_ptr_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_15_ref = 0;
CHECK((((uint64_t)ret_conv_15_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_15_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_15_var);
ret_conv_15_ref = (uint64_t)ret_conv_15_var.inner;
if (ret_conv_15_var.is_owned) {
ret_conv_15_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateAddHTLCZ val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
LDKUpdateAddHTLC val_conv_15_conv;
val_conv_15_conv.inner = (void*)(val_conv_15 & (~1));
val_conv_15_conv.is_owned = (val_conv_15 & 1) || (val_conv_15 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_15_conv);
val_conv_15_conv = UpdateAddHTLC_clone(&val_conv_15_conv);
val_constr.data[p] = val_conv_15_conv;
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFulfillHTLCZ ret_var = CommitmentUpdate_get_update_fulfill_htlcs(&this_ptr_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_19_ref = 0;
CHECK((((uint64_t)ret_conv_19_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_19_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_19_var);
ret_conv_19_ref = (uint64_t)ret_conv_19_var.inner;
if (ret_conv_19_var.is_owned) {
ret_conv_19_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFulfillHTLCZ val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
LDKUpdateFulfillHTLC val_conv_19_conv;
val_conv_19_conv.inner = (void*)(val_conv_19 & (~1));
val_conv_19_conv.is_owned = (val_conv_19 & 1) || (val_conv_19 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_19_conv);
val_conv_19_conv = UpdateFulfillHTLC_clone(&val_conv_19_conv);
val_constr.data[t] = val_conv_19_conv;
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFailHTLCZ ret_var = CommitmentUpdate_get_update_fail_htlcs(&this_ptr_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_16_ref = 0;
CHECK((((uint64_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
ret_conv_16_ref = (uint64_t)ret_conv_16_var.inner;
if (ret_conv_16_var.is_owned) {
ret_conv_16_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFailHTLCZ val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
LDKUpdateFailHTLC val_conv_16_conv;
val_conv_16_conv.inner = (void*)(val_conv_16 & (~1));
val_conv_16_conv.is_owned = (val_conv_16 & 1) || (val_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_16_conv);
val_conv_16_conv = UpdateFailHTLC_clone(&val_conv_16_conv);
val_constr.data[q] = val_conv_16_conv;
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFailMalformedHTLCZ ret_var = CommitmentUpdate_get_update_fail_malformed_htlcs(&this_ptr_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_25_ref = 0;
CHECK((((uint64_t)ret_conv_25_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_25_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_25_var);
ret_conv_25_ref = (uint64_t)ret_conv_25_var.inner;
if (ret_conv_25_var.is_owned) {
ret_conv_25_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_UpdateFailMalformedHTLCZ val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
LDKUpdateFailMalformedHTLC val_conv_25_conv;
val_conv_25_conv.inner = (void*)(val_conv_25 & (~1));
val_conv_25_conv.is_owned = (val_conv_25 & 1) || (val_conv_25 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_25_conv);
val_conv_25_conv = UpdateFailMalformedHTLC_clone(&val_conv_25_conv);
val_constr.data[z] = val_conv_25_conv;
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUpdateFee ret_var = CommitmentUpdate_get_update_fee(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKUpdateFee val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = UpdateFee_clone(&val_conv);
CommitmentUpdate_set_update_fee(&this_ptr_conv, val_conv);
}
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCommitmentSigned ret_var = CommitmentUpdate_get_commitment_signed(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentUpdate this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCommitmentSigned val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = CommitmentSigned_clone(&val_conv);
CommitmentUpdate_set_commitment_signed(&this_ptr_conv, val_conv);
}
LDKUpdateAddHTLC update_add_htlcs_arg_conv_15_conv;
update_add_htlcs_arg_conv_15_conv.inner = (void*)(update_add_htlcs_arg_conv_15 & (~1));
update_add_htlcs_arg_conv_15_conv.is_owned = (update_add_htlcs_arg_conv_15 & 1) || (update_add_htlcs_arg_conv_15 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_add_htlcs_arg_conv_15_conv);
update_add_htlcs_arg_conv_15_conv = UpdateAddHTLC_clone(&update_add_htlcs_arg_conv_15_conv);
update_add_htlcs_arg_constr.data[p] = update_add_htlcs_arg_conv_15_conv;
}
LDKUpdateFulfillHTLC update_fulfill_htlcs_arg_conv_19_conv;
update_fulfill_htlcs_arg_conv_19_conv.inner = (void*)(update_fulfill_htlcs_arg_conv_19 & (~1));
update_fulfill_htlcs_arg_conv_19_conv.is_owned = (update_fulfill_htlcs_arg_conv_19 & 1) || (update_fulfill_htlcs_arg_conv_19 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fulfill_htlcs_arg_conv_19_conv);
update_fulfill_htlcs_arg_conv_19_conv = UpdateFulfillHTLC_clone(&update_fulfill_htlcs_arg_conv_19_conv);
update_fulfill_htlcs_arg_constr.data[t] = update_fulfill_htlcs_arg_conv_19_conv;
}
LDKUpdateFailHTLC update_fail_htlcs_arg_conv_16_conv;
update_fail_htlcs_arg_conv_16_conv.inner = (void*)(update_fail_htlcs_arg_conv_16 & (~1));
update_fail_htlcs_arg_conv_16_conv.is_owned = (update_fail_htlcs_arg_conv_16 & 1) || (update_fail_htlcs_arg_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fail_htlcs_arg_conv_16_conv);
update_fail_htlcs_arg_conv_16_conv = UpdateFailHTLC_clone(&update_fail_htlcs_arg_conv_16_conv);
update_fail_htlcs_arg_constr.data[q] = update_fail_htlcs_arg_conv_16_conv;
}
LDKUpdateFailMalformedHTLC update_fail_malformed_htlcs_arg_conv_25_conv;
update_fail_malformed_htlcs_arg_conv_25_conv.inner = (void*)(update_fail_malformed_htlcs_arg_conv_25 & (~1));
update_fail_malformed_htlcs_arg_conv_25_conv.is_owned = (update_fail_malformed_htlcs_arg_conv_25 & 1) || (update_fail_malformed_htlcs_arg_conv_25 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fail_malformed_htlcs_arg_conv_25_conv);
update_fail_malformed_htlcs_arg_conv_25_conv = UpdateFailMalformedHTLC_clone(&update_fail_malformed_htlcs_arg_conv_25_conv);
update_fail_malformed_htlcs_arg_constr.data[z] = update_fail_malformed_htlcs_arg_conv_25_conv;
}
LDKUpdateFee update_fee_arg_conv;
update_fee_arg_conv.inner = (void*)(update_fee_arg & (~1));
update_fee_arg_conv.is_owned = (update_fee_arg & 1) || (update_fee_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fee_arg_conv);
update_fee_arg_conv = UpdateFee_clone(&update_fee_arg_conv);
LDKCommitmentSigned commitment_signed_arg_conv;
commitment_signed_arg_conv.inner = (void*)(commitment_signed_arg & (~1));
commitment_signed_arg_conv.is_owned = (commitment_signed_arg & 1) || (commitment_signed_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_signed_arg_conv);
commitment_signed_arg_conv = CommitmentSigned_clone(&commitment_signed_arg_conv);
LDKCommitmentUpdate ret_var = CommitmentUpdate_new(update_add_htlcs_arg_constr, update_fulfill_htlcs_arg_constr, update_fail_htlcs_arg_constr, update_fail_malformed_htlcs_arg_constr, update_fee_arg_conv, commitment_signed_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg) {
+ LDKCommitmentUpdate ret_var = CommitmentUpdate_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_CommitmentUpdate_clone_ptr(uint32_t arg) {
+ LDKCommitmentUpdate arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = CommitmentUpdate_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CommitmentUpdate_clone(uint32_t orig) {
LDKCommitmentUpdate orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKCommitmentUpdate ret_var = CommitmentUpdate_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKAcceptChannel obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = AcceptChannel_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKAnnouncementSignatures obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = AnnouncementSignatures_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKChannelReestablish obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelReestablish_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKClosingSigned obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ClosingSigned_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKClosingSignedFeeRange obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ClosingSignedFeeRange_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKCommitmentSigned obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = CommitmentSigned_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKFundingCreated obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = FundingCreated_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKFundingSigned obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = FundingSigned_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKFundingLocked obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = FundingLocked_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKInit obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Init_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKOpenChannel obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = OpenChannel_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKRevokeAndACK obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RevokeAndACK_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKShutdown obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Shutdown_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKUpdateFailHTLC obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UpdateFailHTLC_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKUpdateFailMalformedHTLC obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UpdateFailMalformedHTLC_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKUpdateFee obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UpdateFee_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKUpdateFulfillHTLC obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UpdateFulfillHTLC_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKUpdateAddHTLC obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UpdateAddHTLC_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKPing obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Ping_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKPong obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Pong_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKUnsignedChannelAnnouncement obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UnsignedChannelAnnouncement_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKChannelAnnouncement obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelAnnouncement_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKUnsignedChannelUpdate obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UnsignedChannelUpdate_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKChannelUpdate obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelUpdate_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKErrorMessage obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ErrorMessage_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKUnsignedNodeAnnouncement obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = UnsignedNodeAnnouncement_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKNodeAnnouncement obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NodeAnnouncement_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKQueryShortChannelIds obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = QueryShortChannelIds_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKReplyShortChannelIdsEnd obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ReplyShortChannelIdsEnd_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKQueryChannelRange this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int32_t ret_val = QueryChannelRange_end_blocknum(&this_arg_conv);
return ret_val;
}
LDKQueryChannelRange obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = QueryChannelRange_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKReplyChannelRange obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ReplyChannelRange_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKGossipTimestampFilter obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = GossipTimestampFilter_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKIgnoringMessageHandler this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
IgnoringMessageHandler_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKIgnoringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
*ret_ret = IgnoringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKIgnoringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRoutingMessageHandler* ret_ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
*ret_ret = IgnoringMessageHandler_as_RoutingMessageHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKIgnoringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCustomMessageReader* ret_ret = MALLOC(sizeof(LDKCustomMessageReader), "LDKCustomMessageReader");
*ret_ret = IgnoringMessageHandler_as_CustomMessageReader(&this_arg_conv);
return (uint64_t)ret_ret;
LDKIgnoringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCustomMessageHandler* ret_ret = MALLOC(sizeof(LDKCustomMessageHandler), "LDKCustomMessageHandler");
*ret_ret = IgnoringMessageHandler_as_CustomMessageHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKErroringMessageHandler this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ErroringMessageHandler_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKErroringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
*ret_ret = ErroringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKErroringMessageHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelMessageHandler* ret_ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
*ret_ret = ErroringMessageHandler_as_ChannelMessageHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKMessageHandler this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
MessageHandler_free(this_obj_conv);
}
LDKMessageHandler this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)MessageHandler_get_chan_handler(&this_ptr_conv)) | 1;
return ret_ret;
LDKMessageHandler this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKChannelMessageHandler val_conv = *(LDKChannelMessageHandler*)(val_ptr);
LDKMessageHandler this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
// WARNING: This object doesn't live past this scope, needs clone!
uint64_t ret_ret = ((uint64_t)MessageHandler_get_route_handler(&this_ptr_conv)) | 1;
return ret_ret;
LDKMessageHandler this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKRoutingMessageHandler val_conv = *(LDKRoutingMessageHandler*)(val_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg) {
+ LDKSocketDescriptor* ret_ret = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
+ *ret_ret = SocketDescriptor_clone(arg);
+ return (uint64_t)ret_ret;
+}
+int64_t __attribute__((visibility("default"))) TS_SocketDescriptor_clone_ptr(uint32_t arg) {
+ void* arg_ptr = (void*)(((uint64_t)arg) & ~1);
+ if (!(arg & 1)) { CHECK_ACCESS(arg_ptr); }
+ LDKSocketDescriptor* arg_conv = (LDKSocketDescriptor*)arg_ptr;
+ int64_t ret_val = SocketDescriptor_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_SocketDescriptor_clone(uint32_t orig) {
void* orig_ptr = (void*)(((uint64_t)orig) & ~1);
if (!(orig & 1)) { CHECK_ACCESS(orig_ptr); }
LDKPeerHandleError this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
PeerHandleError_free(this_obj_conv);
}
LDKPeerHandleError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = PeerHandleError_get_no_connection_possible(&this_ptr_conv);
return ret_val;
}
LDKPeerHandleError this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
PeerHandleError_set_no_connection_possible(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg) {
+ LDKPeerHandleError ret_var = PeerHandleError_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_PeerHandleError_clone_ptr(uint32_t arg) {
+ LDKPeerHandleError arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = PeerHandleError_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_PeerHandleError_clone(uint32_t orig) {
LDKPeerHandleError orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPeerHandleError ret_var = PeerHandleError_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPeerManager this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
PeerManager_free(this_obj_conv);
}
LDKMessageHandler message_handler_conv;
message_handler_conv.inner = (void*)(message_handler & (~1));
message_handler_conv.is_owned = (message_handler & 1) || (message_handler == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(message_handler_conv);
// Warning: we need a move here but no clone is available for LDKMessageHandler
LDKSecretKey our_node_secret_ref;
CHECK(*((uint32_t*)our_node_secret) == 32);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_PublicKeyZ ret_var = PeerManager_get_peer_node_ids(&this_arg_conv);
ptrArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native ptrArray Bytes");
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPublicKey their_node_id_ref;
CHECK(*((uint32_t*)their_node_id) == 33);
memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* descriptor_ptr = (void*)(((uint64_t)descriptor) & ~1);
CHECK_ACCESS(descriptor_ptr);
LDKSocketDescriptor descriptor_conv = *(LDKSocketDescriptor*)(descriptor_ptr);
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* descriptor_ptr = (void*)(((uint64_t)descriptor) & ~1);
if (!(descriptor & 1)) { CHECK_ACCESS(descriptor_ptr); }
LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)descriptor_ptr;
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* peer_descriptor_ptr = (void*)(((uint64_t)peer_descriptor) & ~1);
if (!(peer_descriptor & 1)) { CHECK_ACCESS(peer_descriptor_ptr); }
LDKSocketDescriptor* peer_descriptor_conv = (LDKSocketDescriptor*)peer_descriptor_ptr;
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
PeerManager_process_events(&this_arg_conv);
}
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* descriptor_ptr = (void*)(((uint64_t)descriptor) & ~1);
if (!(descriptor & 1)) { CHECK_ACCESS(descriptor_ptr); }
LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)descriptor_ptr;
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPublicKey node_id_ref;
CHECK(*((uint32_t*)node_id) == 33);
memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33);
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
PeerManager_disconnect_all_peers(&this_arg_conv);
}
LDKPeerManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
PeerManager_timer_tick_occurred(&this_arg_conv);
}
LDKOutPoint funding_outpoint_conv;
funding_outpoint_conv.inner = (void*)(funding_outpoint & (~1));
funding_outpoint_conv.is_owned = (funding_outpoint & 1) || (funding_outpoint == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
LDKTransaction ret_var = build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script_ref, to_counterparty_script_ref, funding_outpoint_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
LDKTxCreationKeys this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
TxCreationKeys_free(this_obj_conv);
}
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), TxCreationKeys_get_per_commitment_point(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), TxCreationKeys_get_revocation_key(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), TxCreationKeys_get_broadcaster_htlc_key(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), TxCreationKeys_get_countersignatory_htlc_key(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), TxCreationKeys_get_broadcaster_delayed_payment_key(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKTxCreationKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg) {
+ LDKTxCreationKeys ret_var = TxCreationKeys_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_TxCreationKeys_clone_ptr(uint32_t arg) {
+ LDKTxCreationKeys arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = TxCreationKeys_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_TxCreationKeys_clone(uint32_t orig) {
LDKTxCreationKeys orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKTxCreationKeys ret_var = TxCreationKeys_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKTxCreationKeys obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = TxCreationKeys_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKChannelPublicKeys this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelPublicKeys_free(this_obj_conv);
}
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelPublicKeys_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelPublicKeys_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelPublicKeys_get_payment_point(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelPublicKeys_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ChannelPublicKeys_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKChannelPublicKeys this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg) {
+ LDKChannelPublicKeys ret_var = ChannelPublicKeys_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelPublicKeys_clone_ptr(uint32_t arg) {
+ LDKChannelPublicKeys arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelPublicKeys_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelPublicKeys_clone(uint32_t orig) {
LDKChannelPublicKeys orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelPublicKeys ret_var = ChannelPublicKeys_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelPublicKeys obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelPublicKeys_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKChannelPublicKeys broadcaster_keys_conv;
broadcaster_keys_conv.inner = (void*)(broadcaster_keys & (~1));
broadcaster_keys_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(broadcaster_keys_conv);
LDKChannelPublicKeys countersignatory_keys_conv;
countersignatory_keys_conv.inner = (void*)(countersignatory_keys & (~1));
countersignatory_keys_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(countersignatory_keys_conv);
LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
*ret_conv = TxCreationKeys_from_channel_static_keys(per_commitment_point_ref, &broadcaster_keys_conv, &countersignatory_keys_conv);
return (uint64_t)ret_conv;
LDKHTLCOutputInCommitment this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
HTLCOutputInCommitment_free(this_obj_conv);
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = HTLCOutputInCommitment_get_offered(&this_ptr_conv);
return ret_val;
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
HTLCOutputInCommitment_set_offered(&this_ptr_conv, val);
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = HTLCOutputInCommitment_get_amount_msat(&this_ptr_conv);
return ret_val;
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
HTLCOutputInCommitment_set_amount_msat(&this_ptr_conv, val);
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = HTLCOutputInCommitment_get_cltv_expiry(&this_ptr_conv);
return ret_val;
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
HTLCOutputInCommitment_set_cltv_expiry(&this_ptr_conv, val);
}
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *HTLCOutputInCommitment_get_payment_hash(&this_ptr_conv), 32);
return ret_arr;
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
*ret_copy = HTLCOutputInCommitment_get_transaction_output_index(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKHTLCOutputInCommitment this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg) {
+ LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_HTLCOutputInCommitment_clone_ptr(uint32_t arg) {
+ LDKHTLCOutputInCommitment arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = HTLCOutputInCommitment_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_HTLCOutputInCommitment_clone(uint32_t orig) {
LDKHTLCOutputInCommitment orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKHTLCOutputInCommitment obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = HTLCOutputInCommitment_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKHTLCOutputInCommitment htlc_conv;
htlc_conv.inner = (void*)(htlc & (~1));
htlc_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
LDKTxCreationKeys keys_conv;
keys_conv.inner = (void*)(keys & (~1));
keys_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(keys_conv);
LDKCVec_u8Z ret_var = get_htlc_redeemscript(&htlc_conv, &keys_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKHTLCOutputInCommitment htlc_conv;
htlc_conv.inner = (void*)(htlc & (~1));
htlc_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
LDKPublicKey broadcaster_delayed_payment_key_ref;
CHECK(*((uint32_t*)broadcaster_delayed_payment_key) == 33);
memcpy(broadcaster_delayed_payment_key_ref.compressed_form, (uint8_t*)(broadcaster_delayed_payment_key + 4), 33);
LDKChannelTransactionParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelTransactionParameters_free(this_obj_conv);
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelPublicKeys ret_var = ChannelTransactionParameters_get_holder_pubkeys(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelPublicKeys val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelPublicKeys_clone(&val_conv);
ChannelTransactionParameters_set_holder_pubkeys(&this_ptr_conv, val_conv);
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = ChannelTransactionParameters_get_holder_selected_contest_delay(&this_ptr_conv);
return ret_val;
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelTransactionParameters_set_holder_selected_contest_delay(&this_ptr_conv, val);
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = ChannelTransactionParameters_get_is_outbound_from_holder(&this_ptr_conv);
return ret_val;
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ChannelTransactionParameters_set_is_outbound_from_holder(&this_ptr_conv, val);
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCounterpartyChannelTransactionParameters ret_var = ChannelTransactionParameters_get_counterparty_parameters(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCounterpartyChannelTransactionParameters val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = CounterpartyChannelTransactionParameters_clone(&val_conv);
ChannelTransactionParameters_set_counterparty_parameters(&this_ptr_conv, val_conv);
}
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint ret_var = ChannelTransactionParameters_get_funding_outpoint(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKOutPoint val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = OutPoint_clone(&val_conv);
ChannelTransactionParameters_set_funding_outpoint(&this_ptr_conv, val_conv);
}
LDKChannelPublicKeys holder_pubkeys_arg_conv;
holder_pubkeys_arg_conv.inner = (void*)(holder_pubkeys_arg & (~1));
holder_pubkeys_arg_conv.is_owned = (holder_pubkeys_arg & 1) || (holder_pubkeys_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_pubkeys_arg_conv);
holder_pubkeys_arg_conv = ChannelPublicKeys_clone(&holder_pubkeys_arg_conv);
LDKCounterpartyChannelTransactionParameters counterparty_parameters_arg_conv;
counterparty_parameters_arg_conv.inner = (void*)(counterparty_parameters_arg & (~1));
counterparty_parameters_arg_conv.is_owned = (counterparty_parameters_arg & 1) || (counterparty_parameters_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(counterparty_parameters_arg_conv);
counterparty_parameters_arg_conv = CounterpartyChannelTransactionParameters_clone(&counterparty_parameters_arg_conv);
LDKOutPoint funding_outpoint_arg_conv;
funding_outpoint_arg_conv.inner = (void*)(funding_outpoint_arg & (~1));
funding_outpoint_arg_conv.is_owned = (funding_outpoint_arg & 1) || (funding_outpoint_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_arg_conv);
funding_outpoint_arg_conv = OutPoint_clone(&funding_outpoint_arg_conv);
LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_new(holder_pubkeys_arg_conv, holder_selected_contest_delay_arg, is_outbound_from_holder_arg, counterparty_parameters_arg_conv, funding_outpoint_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg) {
+ LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelTransactionParameters_clone_ptr(uint32_t arg) {
+ LDKChannelTransactionParameters arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelTransactionParameters_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelTransactionParameters_clone(uint32_t orig) {
LDKChannelTransactionParameters orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCounterpartyChannelTransactionParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
CounterpartyChannelTransactionParameters_free(this_obj_conv);
}
LDKCounterpartyChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelPublicKeys ret_var = CounterpartyChannelTransactionParameters_get_pubkeys(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCounterpartyChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelPublicKeys val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelPublicKeys_clone(&val_conv);
CounterpartyChannelTransactionParameters_set_pubkeys(&this_ptr_conv, val_conv);
}
LDKCounterpartyChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = CounterpartyChannelTransactionParameters_get_selected_contest_delay(&this_ptr_conv);
return ret_val;
}
LDKCounterpartyChannelTransactionParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
CounterpartyChannelTransactionParameters_set_selected_contest_delay(&this_ptr_conv, val);
}
LDKChannelPublicKeys pubkeys_arg_conv;
pubkeys_arg_conv.inner = (void*)(pubkeys_arg & (~1));
pubkeys_arg_conv.is_owned = (pubkeys_arg & 1) || (pubkeys_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_arg_conv);
pubkeys_arg_conv = ChannelPublicKeys_clone(&pubkeys_arg_conv);
LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_new(pubkeys_arg_conv, selected_contest_delay_arg);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg) {
+ LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_CounterpartyChannelTransactionParameters_clone_ptr(uint32_t arg) {
+ LDKCounterpartyChannelTransactionParameters arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = CounterpartyChannelTransactionParameters_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CounterpartyChannelTransactionParameters_clone(uint32_t orig) {
LDKCounterpartyChannelTransactionParameters orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = ChannelTransactionParameters_is_populated(&this_arg_conv);
return ret_val;
}
LDKChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_holder_broadcastable(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_counterparty_broadcastable(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCounterpartyChannelTransactionParameters obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = CounterpartyChannelTransactionParameters_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKChannelTransactionParameters obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelTransactionParameters_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKDirectedChannelTransactionParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DirectedChannelTransactionParameters_free(this_obj_conv);
}
LDKDirectedChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_broadcaster_pubkeys(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDirectedChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_countersignatory_pubkeys(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDirectedChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int16_t ret_val = DirectedChannelTransactionParameters_contest_delay(&this_arg_conv);
return ret_val;
}
LDKDirectedChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = DirectedChannelTransactionParameters_is_outbound(&this_arg_conv);
return ret_val;
}
LDKDirectedChannelTransactionParameters this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKOutPoint ret_var = DirectedChannelTransactionParameters_funding_outpoint(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKHolderCommitmentTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
HolderCommitmentTransaction_free(this_obj_conv);
}
LDKHolderCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), HolderCommitmentTransaction_get_counterparty_sig(&this_ptr_conv).compact_form, 64);
return ret_arr;
LDKHolderCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKSignature val_ref;
CHECK(*((uint32_t*)val) == 64);
memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
LDKHolderCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_SignatureZ val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
HolderCommitmentTransaction_set_counterparty_htlc_sigs(&this_ptr_conv, val_constr);
}
+static inline uint64_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg) {
+ LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_HolderCommitmentTransaction_clone_ptr(uint32_t arg) {
+ LDKHolderCommitmentTransaction arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = HolderCommitmentTransaction_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_HolderCommitmentTransaction_clone(uint32_t orig) {
LDKHolderCommitmentTransaction orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKHolderCommitmentTransaction obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = HolderCommitmentTransaction_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKCommitmentTransaction commitment_tx_conv;
commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
commitment_tx_conv.is_owned = (commitment_tx & 1) || (commitment_tx == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
commitment_tx_conv = CommitmentTransaction_clone(&commitment_tx_conv);
LDKSignature counterparty_sig_ref;
CHECK(*((uint32_t*)counterparty_sig) == 64);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKBuiltCommitmentTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
BuiltCommitmentTransaction_free(this_obj_conv);
}
LDKBuiltCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKTransaction ret_var = BuiltCommitmentTransaction_get_transaction(&this_ptr_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKBuiltCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKTransaction val_ref;
val_ref.datalen = *((uint32_t*)val);
val_ref.data = MALLOC(val_ref.datalen, "LDKTransaction Bytes");
LDKBuiltCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *BuiltCommitmentTransaction_get_txid(&this_ptr_conv), 32);
return ret_arr;
LDKBuiltCommitmentTransaction this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg) {
+ LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_BuiltCommitmentTransaction_clone_ptr(uint32_t arg) {
+ LDKBuiltCommitmentTransaction arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = BuiltCommitmentTransaction_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_BuiltCommitmentTransaction_clone(uint32_t orig) {
LDKBuiltCommitmentTransaction orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKBuiltCommitmentTransaction obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = BuiltCommitmentTransaction_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKBuiltCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKu8slice funding_redeemscript_ref;
funding_redeemscript_ref.datalen = *((uint32_t*)funding_redeemscript);
funding_redeemscript_ref.data = (int8_t*)(funding_redeemscript + 4);
LDKBuiltCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char funding_key_arr[32];
CHECK(*((uint32_t*)funding_key) == 32);
memcpy(funding_key_arr, (uint8_t*)(funding_key + 4), 32);
LDKClosingTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ClosingTransaction_free(this_obj_conv);
}
+static inline uint64_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg) {
+ LDKClosingTransaction ret_var = ClosingTransaction_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ClosingTransaction_clone_ptr(uint32_t arg) {
+ LDKClosingTransaction arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ClosingTransaction_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ClosingTransaction_clone(uint32_t orig) {
LDKClosingTransaction orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKClosingTransaction ret_var = ClosingTransaction_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingTransaction o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = ClosingTransaction_hash(&o_conv);
return ret_val;
}
LDKOutPoint funding_outpoint_conv;
funding_outpoint_conv.inner = (void*)(funding_outpoint & (~1));
funding_outpoint_conv.is_owned = (funding_outpoint & 1) || (funding_outpoint == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
LDKClosingTransaction ret_var = ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script_ref, to_counterparty_script_ref, funding_outpoint_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTrustedClosingTransaction ret_var = ClosingTransaction_trust(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKOutPoint funding_outpoint_conv;
funding_outpoint_conv.inner = (void*)(funding_outpoint & (~1));
funding_outpoint_conv.is_owned = (funding_outpoint & 1) || (funding_outpoint == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
*ret_conv = ClosingTransaction_verify(&this_arg_conv, funding_outpoint_conv);
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = ClosingTransaction_to_holder_value_sat(&this_arg_conv);
return ret_val;
}
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = ClosingTransaction_to_counterparty_value_sat(&this_arg_conv);
return ret_val;
}
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKu8slice ret_var = ClosingTransaction_to_holder_script(&this_arg_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKu8slice ret_var = ClosingTransaction_to_counterparty_script(&this_arg_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKTrustedClosingTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
TrustedClosingTransaction_free(this_obj_conv);
}
LDKTrustedClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTransaction ret_var = TrustedClosingTransaction_built_transaction(&this_arg_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKTrustedClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKu8slice funding_redeemscript_ref;
funding_redeemscript_ref.datalen = *((uint32_t*)funding_redeemscript);
funding_redeemscript_ref.data = (int8_t*)(funding_redeemscript + 4);
LDKTrustedClosingTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char funding_key_arr[32];
CHECK(*((uint32_t*)funding_key) == 32);
memcpy(funding_key_arr, (uint8_t*)(funding_key + 4), 32);
LDKCommitmentTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
CommitmentTransaction_free(this_obj_conv);
}
+static inline uint64_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg) {
+ LDKCommitmentTransaction ret_var = CommitmentTransaction_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_CommitmentTransaction_clone_ptr(uint32_t arg) {
+ LDKCommitmentTransaction arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = CommitmentTransaction_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_CommitmentTransaction_clone(uint32_t orig) {
LDKCommitmentTransaction orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKCommitmentTransaction ret_var = CommitmentTransaction_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentTransaction obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = CommitmentTransaction_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = CommitmentTransaction_commitment_number(&this_arg_conv);
return ret_val;
}
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = CommitmentTransaction_to_broadcaster_value_sat(&this_arg_conv);
return ret_val;
}
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = CommitmentTransaction_to_countersignatory_value_sat(&this_arg_conv);
return ret_val;
}
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int32_t ret_val = CommitmentTransaction_feerate_per_kw(&this_arg_conv);
return ret_val;
}
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTrustedCommitmentTransaction ret_var = CommitmentTransaction_trust(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKDirectedChannelTransactionParameters channel_parameters_conv;
channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
channel_parameters_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
LDKChannelPublicKeys broadcaster_keys_conv;
broadcaster_keys_conv.inner = (void*)(broadcaster_keys & (~1));
broadcaster_keys_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(broadcaster_keys_conv);
LDKChannelPublicKeys countersignatory_keys_conv;
countersignatory_keys_conv.inner = (void*)(countersignatory_keys & (~1));
countersignatory_keys_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(countersignatory_keys_conv);
LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
*ret_conv = CommitmentTransaction_verify(&this_arg_conv, &channel_parameters_conv, &broadcaster_keys_conv, &countersignatory_keys_conv);
return (uint64_t)ret_conv;
LDKTrustedCommitmentTransaction this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
TrustedCommitmentTransaction_free(this_obj_conv);
}
LDKTrustedCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), TrustedCommitmentTransaction_txid(&this_arg_conv).data, 32);
return ret_arr;
LDKTrustedCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKBuiltCommitmentTransaction ret_var = TrustedCommitmentTransaction_built_transaction(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKTrustedCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKTxCreationKeys ret_var = TrustedCommitmentTransaction_keys(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKTrustedCommitmentTransaction this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char htlc_base_key_arr[32];
CHECK(*((uint32_t*)htlc_base_key) == 32);
memcpy(htlc_base_key_arr, (uint8_t*)(htlc_base_key + 4), 32);
LDKDirectedChannelTransactionParameters channel_parameters_conv;
channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
channel_parameters_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
*ret_conv = TrustedCommitmentTransaction_get_htlc_sigs(&this_arg_conv, htlc_base_key_ref, &channel_parameters_conv);
return (uint64_t)ret_conv;
LDKInitFeatures a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKInitFeatures b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = InitFeatures_eq(&a_conv, &b_conv);
return ret_val;
}
LDKNodeFeatures a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKNodeFeatures b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = NodeFeatures_eq(&a_conv, &b_conv);
return ret_val;
}
LDKChannelFeatures a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKChannelFeatures b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = ChannelFeatures_eq(&a_conv, &b_conv);
return ret_val;
}
LDKInvoiceFeatures a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKInvoiceFeatures b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = InvoiceFeatures_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg) {
+ LDKInitFeatures ret_var = InitFeatures_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_InitFeatures_clone_ptr(uint32_t arg) {
+ LDKInitFeatures arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = InitFeatures_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_InitFeatures_clone(uint32_t orig) {
LDKInitFeatures orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInitFeatures ret_var = InitFeatures_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg) {
+ LDKNodeFeatures ret_var = NodeFeatures_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_NodeFeatures_clone_ptr(uint32_t arg) {
+ LDKNodeFeatures arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NodeFeatures_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_NodeFeatures_clone(uint32_t orig) {
LDKNodeFeatures orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNodeFeatures ret_var = NodeFeatures_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg) {
+ LDKChannelFeatures ret_var = ChannelFeatures_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelFeatures_clone_ptr(uint32_t arg) {
+ LDKChannelFeatures arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelFeatures_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelFeatures_clone(uint32_t orig) {
LDKChannelFeatures orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelFeatures ret_var = ChannelFeatures_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg) {
+ LDKInvoiceFeatures ret_var = InvoiceFeatures_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_InvoiceFeatures_clone_ptr(uint32_t arg) {
+ LDKInvoiceFeatures arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = InvoiceFeatures_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_InvoiceFeatures_clone(uint32_t orig) {
LDKInvoiceFeatures orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInvoiceFeatures ret_var = InvoiceFeatures_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInitFeatures this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InitFeatures_free(this_obj_conv);
}
LDKNodeFeatures this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NodeFeatures_free(this_obj_conv);
}
LDKChannelFeatures this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelFeatures_free(this_obj_conv);
}
LDKInvoiceFeatures this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InvoiceFeatures_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInitFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = InitFeatures_requires_unknown_bits(&this_arg_conv);
return ret_val;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = NodeFeatures_requires_unknown_bits(&this_arg_conv);
return ret_val;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = ChannelFeatures_requires_unknown_bits(&this_arg_conv);
return ret_val;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvoiceFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = InvoiceFeatures_requires_unknown_bits(&this_arg_conv);
return ret_val;
}
LDKInitFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = InitFeatures_supports_payment_secret(&this_arg_conv);
return ret_val;
}
LDKNodeFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = NodeFeatures_supports_payment_secret(&this_arg_conv);
return ret_val;
}
LDKInvoiceFeatures this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = InvoiceFeatures_supports_payment_secret(&this_arg_conv);
return ret_val;
}
LDKInitFeatures obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = InitFeatures_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKNodeFeatures obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NodeFeatures_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKChannelFeatures obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelFeatures_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKInvoiceFeatures obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = InvoiceFeatures_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKShutdownScript this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ShutdownScript_free(this_obj_conv);
}
+static inline uint64_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg) {
+ LDKShutdownScript ret_var = ShutdownScript_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ShutdownScript_clone_ptr(uint32_t arg) {
+ LDKShutdownScript arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ShutdownScript_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ShutdownScript_clone(uint32_t orig) {
LDKShutdownScript orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKShutdownScript ret_var = ShutdownScript_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvalidShutdownScript this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InvalidShutdownScript_free(this_obj_conv);
}
LDKInvalidShutdownScript this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKu8slice ret_var = InvalidShutdownScript_get_script(&this_ptr_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKInvalidShutdownScript this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u8Z val_ref;
val_ref.datalen = *((uint32_t*)val);
val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg) {
+ LDKInvalidShutdownScript ret_var = InvalidShutdownScript_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_InvalidShutdownScript_clone_ptr(uint32_t arg) {
+ LDKInvalidShutdownScript arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = InvalidShutdownScript_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_InvalidShutdownScript_clone(uint32_t orig) {
LDKInvalidShutdownScript orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInvalidShutdownScript ret_var = InvalidShutdownScript_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKShutdownScript obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ShutdownScript_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKShutdownScript this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
this_arg_conv = ShutdownScript_clone(&this_arg_conv);
LDKCVec_u8Z ret_var = ShutdownScript_into_inner(this_arg_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
LDKShutdownScript this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ShutdownScript_as_legacy_pubkey(&this_arg_conv).compressed_form, 33);
return ret_arr;
LDKShutdownScript this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInitFeatures features_conv;
features_conv.inner = (void*)(features & (~1));
features_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_conv);
jboolean ret_val = ShutdownScript_is_compatible(&this_arg_conv, &features_conv);
return ret_val;
}
CustomMessageReader_free(this_ptr_conv);
}
+static inline uint64_t Type_clone_ptr(LDKType *NONNULL_PTR arg) {
+ LDKType* ret_ret = MALLOC(sizeof(LDKType), "LDKType");
+ *ret_ret = Type_clone(arg);
+ return (uint64_t)ret_ret;
+}
+int64_t __attribute__((visibility("default"))) TS_Type_clone_ptr(uint32_t arg) {
+ void* arg_ptr = (void*)(((uint64_t)arg) & ~1);
+ if (!(arg & 1)) { CHECK_ACCESS(arg_ptr); }
+ LDKType* arg_conv = (LDKType*)arg_ptr;
+ int64_t ret_val = Type_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Type_clone(uint32_t orig) {
void* orig_ptr = (void*)(((uint64_t)orig) & ~1);
if (!(orig & 1)) { CHECK_ACCESS(orig_ptr); }
LDKLockableScore this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
LockableScore_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKLockableScore obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = LockableScore_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKNodeId this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NodeId_free(this_obj_conv);
}
+static inline uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg) {
+ LDKNodeId ret_var = NodeId_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_NodeId_clone_ptr(uint32_t arg) {
+ LDKNodeId arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NodeId_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_NodeId_clone(uint32_t orig) {
LDKNodeId orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNodeId ret_var = NodeId_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeId this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKu8slice ret_var = NodeId_as_slice(&this_arg_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKNodeId o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = NodeId_hash(&o_conv);
return ret_val;
}
LDKNodeId obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NodeId_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKNetworkGraph this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NetworkGraph_free(this_obj_conv);
}
+static inline uint64_t NetworkGraph_clone_ptr(LDKNetworkGraph *NONNULL_PTR arg) {
+ LDKNetworkGraph ret_var = NetworkGraph_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_NetworkGraph_clone_ptr(uint32_t arg) {
+ LDKNetworkGraph arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NetworkGraph_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_clone(uint32_t orig) {
LDKNetworkGraph orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNetworkGraph ret_var = NetworkGraph_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKReadOnlyNetworkGraph this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ReadOnlyNetworkGraph_free(this_obj_conv);
}
NetworkUpdate_free(this_ptr_conv);
}
+static inline uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg) {
+ LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
+ *ret_copy = NetworkUpdate_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_NetworkUpdate_clone_ptr(uint32_t arg) {
+ LDKNetworkUpdate* arg_conv = (LDKNetworkUpdate*)arg;
+ int64_t ret_val = NetworkUpdate_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_NetworkUpdate_clone(uint32_t orig) {
LDKNetworkUpdate* orig_conv = (LDKNetworkUpdate*)orig;
LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = (msg & 1) || (msg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
msg_conv = ChannelUpdate_clone(&msg_conv);
LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
*ret_copy = NetworkUpdate_channel_update_message(msg_conv);
return ret_arr;
}
+uint32_t __attribute__((visibility("default"))) TS_NetworkUpdate_read(int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = *((uint32_t*)ser);
+ ser_ref.data = (int8_t*)(ser + 4);
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
+ *ret_conv = NetworkUpdate_read(ser_ref);
+ return (uint64_t)ret_conv;
+}
+
uint32_t __attribute__((visibility("default"))) TS_NetGraphMsgHandler_as_EventHandler(uint32_t this_arg) {
LDKNetGraphMsgHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKEventHandler* ret_ret = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
*ret_ret = NetGraphMsgHandler_as_EventHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKNetGraphMsgHandler this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NetGraphMsgHandler_free(this_obj_conv);
}
LDKNetworkGraph network_graph_conv;
network_graph_conv.inner = (void*)(network_graph & (~1));
network_graph_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
void* chain_access_ptr = (void*)(((uint64_t)chain_access) & ~1);
CHECK_ACCESS(chain_access_ptr);
LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNetGraphMsgHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* chain_access_ptr = (void*)(((uint64_t)chain_access) & ~1);
CHECK_ACCESS(chain_access_ptr);
LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
LDKNetGraphMsgHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRoutingMessageHandler* ret_ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
*ret_ret = NetGraphMsgHandler_as_RoutingMessageHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKNetGraphMsgHandler this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
*ret_ret = NetGraphMsgHandler_as_MessageSendEventsProvider(&this_arg_conv);
return (uint64_t)ret_ret;
LDKDirectionalChannelInfo this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DirectionalChannelInfo_free(this_obj_conv);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = DirectionalChannelInfo_get_last_update(&this_ptr_conv);
return ret_val;
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DirectionalChannelInfo_set_last_update(&this_ptr_conv, val);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
jboolean ret_val = DirectionalChannelInfo_get_enabled(&this_ptr_conv);
return ret_val;
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DirectionalChannelInfo_set_enabled(&this_ptr_conv, val);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = DirectionalChannelInfo_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DirectionalChannelInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = DirectionalChannelInfo_get_htlc_minimum_msat(&this_ptr_conv);
return ret_val;
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
DirectionalChannelInfo_set_htlc_minimum_msat(&this_ptr_conv, val);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = DirectionalChannelInfo_get_htlc_maximum_msat(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees ret_var = DirectionalChannelInfo_get_fees(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = RoutingFees_clone(&val_conv);
DirectionalChannelInfo_set_fees(&this_ptr_conv, val_conv);
}
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelUpdate ret_var = DirectionalChannelInfo_get_last_update_message(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDirectionalChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelUpdate val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelUpdate_clone(&val_conv);
DirectionalChannelInfo_set_last_update_message(&this_ptr_conv, val_conv);
}
LDKRoutingFees fees_arg_conv;
fees_arg_conv.inner = (void*)(fees_arg & (~1));
fees_arg_conv.is_owned = (fees_arg & 1) || (fees_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(fees_arg_conv);
fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
LDKChannelUpdate last_update_message_arg_conv;
last_update_message_arg_conv.inner = (void*)(last_update_message_arg & (~1));
last_update_message_arg_conv.is_owned = (last_update_message_arg & 1) || (last_update_message_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(last_update_message_arg_conv);
last_update_message_arg_conv = ChannelUpdate_clone(&last_update_message_arg_conv);
LDKDirectionalChannelInfo ret_var = DirectionalChannelInfo_new(last_update_arg, enabled_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg_conv, fees_arg_conv, last_update_message_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t DirectionalChannelInfo_clone_ptr(LDKDirectionalChannelInfo *NONNULL_PTR arg) {
+ LDKDirectionalChannelInfo ret_var = DirectionalChannelInfo_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_clone_ptr(uint32_t arg) {
+ LDKDirectionalChannelInfo arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = DirectionalChannelInfo_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_clone(uint32_t orig) {
LDKDirectionalChannelInfo orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKDirectionalChannelInfo ret_var = DirectionalChannelInfo_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDirectionalChannelInfo obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = DirectionalChannelInfo_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKChannelInfo this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ChannelInfo_free(this_obj_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures ret_var = ChannelInfo_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelFeatures_clone(&val_conv);
ChannelInfo_set_features(&this_ptr_conv, val_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeId ret_var = ChannelInfo_get_node_one(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeId val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeId_clone(&val_conv);
ChannelInfo_set_node_one(&this_ptr_conv, val_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKDirectionalChannelInfo ret_var = ChannelInfo_get_one_to_two(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKDirectionalChannelInfo val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = DirectionalChannelInfo_clone(&val_conv);
ChannelInfo_set_one_to_two(&this_ptr_conv, val_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeId ret_var = ChannelInfo_get_node_two(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeId val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeId_clone(&val_conv);
ChannelInfo_set_node_two(&this_ptr_conv, val_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKDirectionalChannelInfo ret_var = ChannelInfo_get_two_to_one(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKDirectionalChannelInfo val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = DirectionalChannelInfo_clone(&val_conv);
ChannelInfo_set_two_to_one(&this_ptr_conv, val_conv);
}
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = ChannelInfo_get_capacity_sats(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelAnnouncement ret_var = ChannelInfo_get_announcement_message(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelAnnouncement val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelAnnouncement_clone(&val_conv);
ChannelInfo_set_announcement_message(&this_ptr_conv, val_conv);
}
LDKChannelFeatures features_arg_conv;
features_arg_conv.inner = (void*)(features_arg & (~1));
features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
features_arg_conv = ChannelFeatures_clone(&features_arg_conv);
LDKNodeId node_one_arg_conv;
node_one_arg_conv.inner = (void*)(node_one_arg & (~1));
node_one_arg_conv.is_owned = (node_one_arg & 1) || (node_one_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(node_one_arg_conv);
node_one_arg_conv = NodeId_clone(&node_one_arg_conv);
LDKDirectionalChannelInfo one_to_two_arg_conv;
one_to_two_arg_conv.inner = (void*)(one_to_two_arg & (~1));
one_to_two_arg_conv.is_owned = (one_to_two_arg & 1) || (one_to_two_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(one_to_two_arg_conv);
one_to_two_arg_conv = DirectionalChannelInfo_clone(&one_to_two_arg_conv);
LDKNodeId node_two_arg_conv;
node_two_arg_conv.inner = (void*)(node_two_arg & (~1));
node_two_arg_conv.is_owned = (node_two_arg & 1) || (node_two_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(node_two_arg_conv);
node_two_arg_conv = NodeId_clone(&node_two_arg_conv);
LDKDirectionalChannelInfo two_to_one_arg_conv;
two_to_one_arg_conv.inner = (void*)(two_to_one_arg & (~1));
two_to_one_arg_conv.is_owned = (two_to_one_arg & 1) || (two_to_one_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(two_to_one_arg_conv);
two_to_one_arg_conv = DirectionalChannelInfo_clone(&two_to_one_arg_conv);
void* capacity_sats_arg_ptr = (void*)(((uint64_t)capacity_sats_arg) & ~1);
CHECK_ACCESS(capacity_sats_arg_ptr);
LDKChannelAnnouncement announcement_message_arg_conv;
announcement_message_arg_conv.inner = (void*)(announcement_message_arg & (~1));
announcement_message_arg_conv.is_owned = (announcement_message_arg & 1) || (announcement_message_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(announcement_message_arg_conv);
announcement_message_arg_conv = ChannelAnnouncement_clone(&announcement_message_arg_conv);
LDKChannelInfo ret_var = ChannelInfo_new(features_arg_conv, node_one_arg_conv, one_to_two_arg_conv, node_two_arg_conv, two_to_one_arg_conv, capacity_sats_arg_conv, announcement_message_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg) {
+ LDKChannelInfo ret_var = ChannelInfo_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ChannelInfo_clone_ptr(uint32_t arg) {
+ LDKChannelInfo arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ChannelInfo_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_clone(uint32_t orig) {
LDKChannelInfo orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKChannelInfo ret_var = ChannelInfo_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKChannelInfo obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ChannelInfo_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKRoutingFees this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RoutingFees_free(this_obj_conv);
}
LDKRoutingFees this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = RoutingFees_get_base_msat(&this_ptr_conv);
return ret_val;
}
LDKRoutingFees this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RoutingFees_set_base_msat(&this_ptr_conv, val);
}
LDKRoutingFees this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = RoutingFees_get_proportional_millionths(&this_ptr_conv);
return ret_val;
}
LDKRoutingFees this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RoutingFees_set_proportional_millionths(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRoutingFees a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRoutingFees b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RoutingFees_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg) {
+ LDKRoutingFees ret_var = RoutingFees_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_RoutingFees_clone_ptr(uint32_t arg) {
+ LDKRoutingFees arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RoutingFees_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_RoutingFees_clone(uint32_t orig) {
LDKRoutingFees orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRoutingFees ret_var = RoutingFees_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRoutingFees o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = RoutingFees_hash(&o_conv);
return ret_val;
}
LDKRoutingFees obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RoutingFees_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKNodeAnnouncementInfo this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NodeAnnouncementInfo_free(this_obj_conv);
}
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures ret_var = NodeAnnouncementInfo_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeFeatures_clone(&val_conv);
NodeAnnouncementInfo_set_features(&this_ptr_conv, val_conv);
}
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = NodeAnnouncementInfo_get_last_update(&this_ptr_conv);
return ret_val;
}
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
NodeAnnouncementInfo_set_last_update(&this_ptr_conv, val);
}
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(3, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *NodeAnnouncementInfo_get_rgb(&this_ptr_conv), 3);
return ret_arr;
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThreeBytes val_ref;
CHECK(*((uint32_t*)val) == 3);
memcpy(val_ref.data, (uint8_t*)(val + 4), 3);
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *NodeAnnouncementInfo_get_alias(&this_ptr_conv), 32);
return ret_arr;
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKThirtyTwoBytes val_ref;
CHECK(*((uint32_t*)val) == 32);
memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_NetAddressZ val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeAnnouncement ret_var = NodeAnnouncementInfo_get_announcement_message(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeAnnouncementInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeAnnouncement val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeAnnouncement_clone(&val_conv);
NodeAnnouncementInfo_set_announcement_message(&this_ptr_conv, val_conv);
}
LDKNodeFeatures features_arg_conv;
features_arg_conv.inner = (void*)(features_arg & (~1));
features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
features_arg_conv = NodeFeatures_clone(&features_arg_conv);
LDKThreeBytes rgb_arg_ref;
CHECK(*((uint32_t*)rgb_arg) == 3);
LDKNodeAnnouncement announcement_message_arg_conv;
announcement_message_arg_conv.inner = (void*)(announcement_message_arg & (~1));
announcement_message_arg_conv.is_owned = (announcement_message_arg & 1) || (announcement_message_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(announcement_message_arg_conv);
announcement_message_arg_conv = NodeAnnouncement_clone(&announcement_message_arg_conv);
LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_new(features_arg_conv, last_update_arg, rgb_arg_ref, alias_arg_ref, addresses_arg_constr, announcement_message_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg) {
+ LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_clone_ptr(uint32_t arg) {
+ LDKNodeAnnouncementInfo arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NodeAnnouncementInfo_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_clone(uint32_t orig) {
LDKNodeAnnouncementInfo orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeAnnouncementInfo obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NodeAnnouncementInfo_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKNodeInfo this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
NodeInfo_free(this_obj_conv);
}
LDKNodeInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_u64Z val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
LDKNodeInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees ret_var = NodeInfo_get_lowest_inbound_channel_fees(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = RoutingFees_clone(&val_conv);
NodeInfo_set_lowest_inbound_channel_fees(&this_ptr_conv, val_conv);
}
LDKNodeInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeAnnouncementInfo ret_var = NodeInfo_get_announcement_info(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeInfo this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeAnnouncementInfo val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeAnnouncementInfo_clone(&val_conv);
NodeInfo_set_announcement_info(&this_ptr_conv, val_conv);
}
LDKRoutingFees lowest_inbound_channel_fees_arg_conv;
lowest_inbound_channel_fees_arg_conv.inner = (void*)(lowest_inbound_channel_fees_arg & (~1));
lowest_inbound_channel_fees_arg_conv.is_owned = (lowest_inbound_channel_fees_arg & 1) || (lowest_inbound_channel_fees_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(lowest_inbound_channel_fees_arg_conv);
lowest_inbound_channel_fees_arg_conv = RoutingFees_clone(&lowest_inbound_channel_fees_arg_conv);
LDKNodeAnnouncementInfo announcement_info_arg_conv;
announcement_info_arg_conv.inner = (void*)(announcement_info_arg & (~1));
announcement_info_arg_conv.is_owned = (announcement_info_arg & 1) || (announcement_info_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(announcement_info_arg_conv);
announcement_info_arg_conv = NodeAnnouncementInfo_clone(&announcement_info_arg_conv);
LDKNodeInfo ret_var = NodeInfo_new(channels_arg_constr, lowest_inbound_channel_fees_arg_conv, announcement_info_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg) {
+ LDKNodeInfo ret_var = NodeInfo_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_NodeInfo_clone_ptr(uint32_t arg) {
+ LDKNodeInfo arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = NodeInfo_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_NodeInfo_clone(uint32_t orig) {
LDKNodeInfo orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKNodeInfo ret_var = NodeInfo_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNodeInfo obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NodeInfo_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKNetworkGraph obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = NetworkGraph_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKReadOnlyNetworkGraph ret_var = NetworkGraph_read_only(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKNodeAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = NetworkGraph_update_node_from_announcement(&this_arg_conv, &msg_conv);
return (uint64_t)ret_conv;
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKUnsignedNodeAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = NetworkGraph_update_node_from_unsigned_announcement(&this_arg_conv, &msg_conv);
return (uint64_t)ret_conv;
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
void* chain_access_ptr = (void*)(((uint64_t)chain_access) & ~1);
CHECK_ACCESS(chain_access_ptr);
LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKUnsignedChannelAnnouncement msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
void* chain_access_ptr = (void*)(((uint64_t)chain_access) & ~1);
CHECK_ACCESS(chain_access_ptr);
LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
NetworkGraph_close_channel_from_update(&this_arg_conv, short_channel_id, is_permanent);
}
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPublicKey _node_id_ref;
CHECK(*((uint32_t*)_node_id) == 33);
memcpy(_node_id_ref.compressed_form, (uint8_t*)(_node_id + 4), 33);
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = NetworkGraph_update_channel(&this_arg_conv, &msg_conv);
return (uint64_t)ret_conv;
LDKNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKUnsignedChannelUpdate msg_conv;
msg_conv.inner = (void*)(msg & (~1));
msg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
*ret_conv = NetworkGraph_update_channel_unsigned(&this_arg_conv, &msg_conv);
return (uint64_t)ret_conv;
LDKReadOnlyNetworkGraph this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPublicKey pubkey_ref;
CHECK(*((uint32_t*)pubkey) == 33);
memcpy(pubkey_ref.compressed_form, (uint8_t*)(pubkey + 4), 33);
LDKRouteHop this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RouteHop_free(this_obj_conv);
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), RouteHop_get_pubkey(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures ret_var = RouteHop_get_node_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKNodeFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = NodeFeatures_clone(&val_conv);
RouteHop_set_node_features(&this_ptr_conv, val_conv);
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = RouteHop_get_short_channel_id(&this_ptr_conv);
return ret_val;
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteHop_set_short_channel_id(&this_ptr_conv, val);
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures ret_var = RouteHop_get_channel_features(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKChannelFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = ChannelFeatures_clone(&val_conv);
RouteHop_set_channel_features(&this_ptr_conv, val_conv);
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = RouteHop_get_fee_msat(&this_ptr_conv);
return ret_val;
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteHop_set_fee_msat(&this_ptr_conv, val);
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = RouteHop_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKRouteHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteHop_set_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKNodeFeatures node_features_arg_conv;
node_features_arg_conv.inner = (void*)(node_features_arg & (~1));
node_features_arg_conv.is_owned = (node_features_arg & 1) || (node_features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(node_features_arg_conv);
node_features_arg_conv = NodeFeatures_clone(&node_features_arg_conv);
LDKChannelFeatures channel_features_arg_conv;
channel_features_arg_conv.inner = (void*)(channel_features_arg & (~1));
channel_features_arg_conv.is_owned = (channel_features_arg & 1) || (channel_features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_features_arg_conv);
channel_features_arg_conv = ChannelFeatures_clone(&channel_features_arg_conv);
LDKRouteHop ret_var = RouteHop_new(pubkey_arg_ref, node_features_arg_conv, short_channel_id_arg, channel_features_arg_conv, fee_msat_arg, cltv_expiry_delta_arg);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg) {
+ LDKRouteHop ret_var = RouteHop_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_RouteHop_clone_ptr(uint32_t arg) {
+ LDKRouteHop arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RouteHop_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_RouteHop_clone(uint32_t orig) {
LDKRouteHop orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRouteHop ret_var = RouteHop_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHop o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = RouteHop_hash(&o_conv);
return ret_val;
}
LDKRouteHop a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRouteHop b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RouteHop_eq(&a_conv, &b_conv);
return ret_val;
}
LDKRouteHop obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RouteHop_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKRoute this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Route_free(this_obj_conv);
}
LDKRoute this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_CVec_RouteHopZZ ret_var = Route_get_paths(&this_ptr_conv);
ptrArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native ptrArray Bytes");
uint64_t ret_conv_12_conv_10_ref = 0;
CHECK((((uint64_t)ret_conv_12_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_12_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_12_conv_10_var);
ret_conv_12_conv_10_ref = (uint64_t)ret_conv_12_conv_10_var.inner;
if (ret_conv_12_conv_10_var.is_owned) {
ret_conv_12_conv_10_ref |= 1;
LDKRoute this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_CVec_RouteHopZZ val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
LDKRouteHop val_conv_12_conv_10_conv;
val_conv_12_conv_10_conv.inner = (void*)(val_conv_12_conv_10 & (~1));
val_conv_12_conv_10_conv.is_owned = (val_conv_12_conv_10 & 1) || (val_conv_12_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_12_conv_10_conv);
val_conv_12_conv_10_conv = RouteHop_clone(&val_conv_12_conv_10_conv);
val_conv_12_constr.data[k] = val_conv_12_conv_10_conv;
}
LDKRoute this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPayee ret_var = Route_get_payee(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRoute this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPayee val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = Payee_clone(&val_conv);
Route_set_payee(&this_ptr_conv, val_conv);
}
LDKRouteHop paths_arg_conv_12_conv_10_conv;
paths_arg_conv_12_conv_10_conv.inner = (void*)(paths_arg_conv_12_conv_10 & (~1));
paths_arg_conv_12_conv_10_conv.is_owned = (paths_arg_conv_12_conv_10 & 1) || (paths_arg_conv_12_conv_10 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(paths_arg_conv_12_conv_10_conv);
paths_arg_conv_12_conv_10_conv = RouteHop_clone(&paths_arg_conv_12_conv_10_conv);
paths_arg_conv_12_constr.data[k] = paths_arg_conv_12_conv_10_conv;
}
LDKPayee payee_arg_conv;
payee_arg_conv.inner = (void*)(payee_arg & (~1));
payee_arg_conv.is_owned = (payee_arg & 1) || (payee_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(payee_arg_conv);
payee_arg_conv = Payee_clone(&payee_arg_conv);
LDKRoute ret_var = Route_new(paths_arg_constr, payee_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg) {
+ LDKRoute ret_var = Route_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Route_clone_ptr(uint32_t arg) {
+ LDKRoute arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Route_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Route_clone(uint32_t orig) {
LDKRoute orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRoute ret_var = Route_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRoute o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = Route_hash(&o_conv);
return ret_val;
}
LDKRoute a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRoute b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = Route_eq(&a_conv, &b_conv);
return ret_val;
}
LDKRoute this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = Route_get_total_fees(&this_arg_conv);
return ret_val;
}
LDKRoute this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = Route_get_total_amount(&this_arg_conv);
return ret_val;
}
LDKRoute obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Route_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKRouteParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RouteParameters_free(this_obj_conv);
}
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPayee ret_var = RouteParameters_get_payee(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPayee val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = Payee_clone(&val_conv);
RouteParameters_set_payee(&this_ptr_conv, val_conv);
}
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = RouteParameters_get_final_value_msat(&this_ptr_conv);
return ret_val;
}
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteParameters_set_final_value_msat(&this_ptr_conv, val);
}
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int32_t ret_val = RouteParameters_get_final_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKRouteParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteParameters_set_final_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKPayee payee_arg_conv;
payee_arg_conv.inner = (void*)(payee_arg & (~1));
payee_arg_conv.is_owned = (payee_arg & 1) || (payee_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(payee_arg_conv);
payee_arg_conv = Payee_clone(&payee_arg_conv);
LDKRouteParameters ret_var = RouteParameters_new(payee_arg_conv, final_value_msat_arg, final_cltv_expiry_delta_arg);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg) {
+ LDKRouteParameters ret_var = RouteParameters_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_RouteParameters_clone_ptr(uint32_t arg) {
+ LDKRouteParameters arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RouteParameters_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_RouteParameters_clone(uint32_t orig) {
LDKRouteParameters orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRouteParameters ret_var = RouteParameters_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteParameters obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RouteParameters_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKPayee this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Payee_free(this_obj_conv);
}
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), Payee_get_pubkey(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInvoiceFeatures ret_var = Payee_get_features(&this_ptr_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKInvoiceFeatures val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = InvoiceFeatures_clone(&val_conv);
Payee_set_features(&this_ptr_conv, val_conv);
}
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_RouteHintZ ret_var = Payee_get_route_hints(&this_ptr_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_11_ref = 0;
CHECK((((uint64_t)ret_conv_11_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_11_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_11_var);
ret_conv_11_ref = (uint64_t)ret_conv_11_var.inner;
if (ret_conv_11_var.is_owned) {
ret_conv_11_ref |= 1;
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_RouteHintZ val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
LDKRouteHint val_conv_11_conv;
val_conv_11_conv.inner = (void*)(val_conv_11 & (~1));
val_conv_11_conv.is_owned = (val_conv_11 & 1) || (val_conv_11 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_11_conv);
val_conv_11_conv = RouteHint_clone(&val_conv_11_conv);
val_constr.data[l] = val_conv_11_conv;
}
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = Payee_get_expiry_time(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKPayee this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKInvoiceFeatures features_arg_conv;
features_arg_conv.inner = (void*)(features_arg & (~1));
features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
features_arg_conv = InvoiceFeatures_clone(&features_arg_conv);
LDKCVec_RouteHintZ route_hints_arg_constr;
route_hints_arg_constr.datalen = *((uint32_t*)route_hints_arg);
LDKRouteHint route_hints_arg_conv_11_conv;
route_hints_arg_conv_11_conv.inner = (void*)(route_hints_arg_conv_11 & (~1));
route_hints_arg_conv_11_conv.is_owned = (route_hints_arg_conv_11 & 1) || (route_hints_arg_conv_11 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_hints_arg_conv_11_conv);
route_hints_arg_conv_11_conv = RouteHint_clone(&route_hints_arg_conv_11_conv);
route_hints_arg_constr.data[l] = route_hints_arg_conv_11_conv;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t Payee_clone_ptr(LDKPayee *NONNULL_PTR arg) {
+ LDKPayee ret_var = Payee_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Payee_clone_ptr(uint32_t arg) {
+ LDKPayee arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Payee_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Payee_clone(uint32_t orig) {
LDKPayee orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPayee ret_var = Payee_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPayee o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = Payee_hash(&o_conv);
return ret_val;
}
LDKPayee a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKPayee b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = Payee_eq(&a_conv, &b_conv);
return ret_val;
}
LDKPayee obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Payee_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHint this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RouteHint_free(this_obj_conv);
}
LDKRouteHint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_RouteHintHopZ ret_var = RouteHint_get_a(&this_ptr_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_14_ref = 0;
CHECK((((uint64_t)ret_conv_14_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_14_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
ret_conv_14_ref = (uint64_t)ret_conv_14_var.inner;
if (ret_conv_14_var.is_owned) {
ret_conv_14_ref |= 1;
LDKRouteHint this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCVec_RouteHintHopZ val_constr;
val_constr.datalen = *((uint32_t*)val);
if (val_constr.datalen > 0)
LDKRouteHintHop val_conv_14_conv;
val_conv_14_conv.inner = (void*)(val_conv_14 & (~1));
val_conv_14_conv.is_owned = (val_conv_14 & 1) || (val_conv_14 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_14_conv);
val_conv_14_conv = RouteHintHop_clone(&val_conv_14_conv);
val_constr.data[o] = val_conv_14_conv;
}
LDKRouteHintHop a_arg_conv_14_conv;
a_arg_conv_14_conv.inner = (void*)(a_arg_conv_14 & (~1));
a_arg_conv_14_conv.is_owned = (a_arg_conv_14 & 1) || (a_arg_conv_14 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_arg_conv_14_conv);
a_arg_conv_14_conv = RouteHintHop_clone(&a_arg_conv_14_conv);
a_arg_constr.data[o] = a_arg_conv_14_conv;
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg) {
+ LDKRouteHint ret_var = RouteHint_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_RouteHint_clone_ptr(uint32_t arg) {
+ LDKRouteHint arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RouteHint_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_RouteHint_clone(uint32_t orig) {
LDKRouteHint orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRouteHint ret_var = RouteHint_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHint o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = RouteHint_hash(&o_conv);
return ret_val;
}
LDKRouteHint a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRouteHint b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RouteHint_eq(&a_conv, &b_conv);
return ret_val;
}
LDKRouteHint obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RouteHint_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKRouteHintHop this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RouteHintHop_free(this_obj_conv);
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), RouteHintHop_get_src_node_id(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = RouteHintHop_get_short_channel_id(&this_ptr_conv);
return ret_val;
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteHintHop_set_short_channel_id(&this_ptr_conv, val);
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees ret_var = RouteHintHop_get_fees(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRoutingFees val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = RoutingFees_clone(&val_conv);
RouteHintHop_set_fees(&this_ptr_conv, val_conv);
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int16_t ret_val = RouteHintHop_get_cltv_expiry_delta(&this_ptr_conv);
return ret_val;
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RouteHintHop_set_cltv_expiry_delta(&this_ptr_conv, val);
}
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = RouteHintHop_get_htlc_minimum_msat(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = RouteHintHop_get_htlc_maximum_msat(&this_ptr_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKRouteHintHop this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
void* val_ptr = (void*)(((uint64_t)val) & ~1);
CHECK_ACCESS(val_ptr);
LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
LDKRoutingFees fees_arg_conv;
fees_arg_conv.inner = (void*)(fees_arg & (~1));
fees_arg_conv.is_owned = (fees_arg & 1) || (fees_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(fees_arg_conv);
fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
void* htlc_minimum_msat_arg_ptr = (void*)(((uint64_t)htlc_minimum_msat_arg) & ~1);
CHECK_ACCESS(htlc_minimum_msat_arg_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg) {
+ LDKRouteHintHop ret_var = RouteHintHop_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_RouteHintHop_clone_ptr(uint32_t arg) {
+ LDKRouteHintHop arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RouteHintHop_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_RouteHintHop_clone(uint32_t orig) {
LDKRouteHintHop orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRouteHintHop ret_var = RouteHintHop_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRouteHintHop o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = RouteHintHop_hash(&o_conv);
return ret_val;
}
LDKRouteHintHop a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRouteHintHop b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RouteHintHop_eq(&a_conv, &b_conv);
return ret_val;
}
LDKRouteHintHop obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = RouteHintHop_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKRouteParameters params_conv;
params_conv.inner = (void*)(params & (~1));
params_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
LDKNetworkGraph network_conv;
network_conv.inner = (void*)(network & (~1));
network_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(network_conv);
LDKCVec_ChannelDetailsZ first_hops_constr;
LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL;
if (first_hops != 0) {
LDKChannelDetails first_hops_conv_16_conv;
first_hops_conv_16_conv.inner = (void*)(first_hops_conv_16 & (~1));
first_hops_conv_16_conv.is_owned = (first_hops_conv_16 & 1) || (first_hops_conv_16 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_conv);
first_hops_constr.data[q] = first_hops_conv_16_conv;
}
first_hops_ptr = &first_hops_constr;
LDKScorer this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Scorer_free(this_obj_conv);
}
LDKScoringParameters this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ScoringParameters_free(this_obj_conv);
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ScoringParameters_get_base_penalty_msat(&this_ptr_conv);
return ret_val;
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ScoringParameters_set_base_penalty_msat(&this_ptr_conv, val);
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ScoringParameters_get_failure_penalty_msat(&this_ptr_conv);
return ret_val;
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ScoringParameters_set_failure_penalty_msat(&this_ptr_conv, val);
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = ScoringParameters_get_failure_penalty_half_life(&this_ptr_conv);
return ret_val;
}
LDKScoringParameters this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
ScoringParameters_set_failure_penalty_half_life(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKScoringParameters obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = ScoringParameters_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKScoringParameters params_conv;
params_conv.inner = (void*)(params & (~1));
params_conv.is_owned = (params & 1) || (params == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
// Warning: we need a move here but no clone is available for LDKScoringParameters
LDKScorer ret_var = Scorer_new(params_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKScorer this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
*ret_ret = Scorer_as_Score(&this_arg_conv);
return (uint64_t)ret_ret;
LDKScorer obj_conv;
obj_conv.inner = (void*)(obj & (~1));
obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
LDKCVec_u8Z ret_var = Scorer_write(&obj_conv);
int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
LDKFilesystemPersister this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
FilesystemPersister_free(this_obj_conv);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKFilesystemPersister this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKStr ret_str = FilesystemPersister_get_data_dir(&this_arg_conv);
jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
Str_free(ret_str);
LDKChannelManager manager_conv;
manager_conv.inner = (void*)(manager & (~1));
manager_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(manager_conv);
LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
*ret_conv = FilesystemPersister_persist_manager(data_dir_conv, &manager_conv);
return (uint64_t)ret_conv;
LDKFilesystemPersister this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
void* keys_manager_ptr = (void*)(((uint64_t)keys_manager) & ~1);
CHECK_ACCESS(keys_manager_ptr);
LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(keys_manager_ptr);
LDKFilesystemPersister this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPersist* ret_ret = MALLOC(sizeof(LDKPersist), "LDKPersist");
*ret_ret = FilesystemPersister_as_Persist(&this_arg_conv);
return (uint64_t)ret_ret;
LDKBackgroundProcessor this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
BackgroundProcessor_free(this_obj_conv);
}
LDKChainMonitor chain_monitor_conv;
chain_monitor_conv.inner = (void*)(chain_monitor & (~1));
chain_monitor_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(chain_monitor_conv);
LDKChannelManager channel_manager_conv;
channel_manager_conv.inner = (void*)(channel_manager & (~1));
channel_manager_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_manager_conv);
LDKNetGraphMsgHandler net_graph_msg_handler_conv;
net_graph_msg_handler_conv.inner = (void*)(net_graph_msg_handler & (~1));
net_graph_msg_handler_conv.is_owned = (net_graph_msg_handler & 1) || (net_graph_msg_handler == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(net_graph_msg_handler_conv);
LDKPeerManager peer_manager_conv;
peer_manager_conv.inner = (void*)(peer_manager & (~1));
peer_manager_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(peer_manager_conv);
void* logger_ptr = (void*)(((uint64_t)logger) & ~1);
CHECK_ACCESS(logger_ptr);
LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKBackgroundProcessor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
// Warning: we need a move here but no clone is available for LDKBackgroundProcessor
LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
*ret_conv = BackgroundProcessor_join(this_arg_conv);
LDKBackgroundProcessor this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
// Warning: we need a move here but no clone is available for LDKBackgroundProcessor
LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
*ret_conv = BackgroundProcessor_stop(this_arg_conv);
LDKInvoice this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Invoice_free(this_obj_conv);
}
LDKInvoice a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKInvoice b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = Invoice_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg) {
+ LDKInvoice ret_var = Invoice_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Invoice_clone_ptr(uint32_t arg) {
+ LDKInvoice arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Invoice_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Invoice_clone(uint32_t orig) {
LDKInvoice orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInvoice ret_var = Invoice_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKSignedRawInvoice this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
SignedRawInvoice_free(this_obj_conv);
}
LDKSignedRawInvoice a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKSignedRawInvoice b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = SignedRawInvoice_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg) {
+ LDKSignedRawInvoice ret_var = SignedRawInvoice_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_SignedRawInvoice_clone_ptr(uint32_t arg) {
+ LDKSignedRawInvoice arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = SignedRawInvoice_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_SignedRawInvoice_clone(uint32_t orig) {
LDKSignedRawInvoice orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKSignedRawInvoice ret_var = SignedRawInvoice_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RawInvoice_free(this_obj_conv);
}
LDKRawInvoice this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRawDataPart ret_var = RawInvoice_get_data(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKRawDataPart val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = RawDataPart_clone(&val_conv);
RawInvoice_set_data(&this_ptr_conv, val_conv);
}
LDKRawInvoice a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRawInvoice b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RawInvoice_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg) {
+ LDKRawInvoice ret_var = RawInvoice_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_RawInvoice_clone_ptr(uint32_t arg) {
+ LDKRawInvoice arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RawInvoice_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_RawInvoice_clone(uint32_t orig) {
LDKRawInvoice orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRawInvoice ret_var = RawInvoice_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawDataPart this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RawDataPart_free(this_obj_conv);
}
LDKRawDataPart this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPositiveTimestamp ret_var = RawDataPart_get_timestamp(&this_ptr_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawDataPart this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPositiveTimestamp val_conv;
val_conv.inner = (void*)(val & (~1));
val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
val_conv = PositiveTimestamp_clone(&val_conv);
RawDataPart_set_timestamp(&this_ptr_conv, val_conv);
}
LDKRawDataPart a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRawDataPart b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RawDataPart_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg) {
+ LDKRawDataPart ret_var = RawDataPart_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_RawDataPart_clone_ptr(uint32_t arg) {
+ LDKRawDataPart arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RawDataPart_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_RawDataPart_clone(uint32_t orig) {
LDKRawDataPart orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRawDataPart ret_var = RawDataPart_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPositiveTimestamp this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
PositiveTimestamp_free(this_obj_conv);
}
LDKPositiveTimestamp a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKPositiveTimestamp b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = PositiveTimestamp_eq(&a_conv, &b_conv);
return ret_val;
}
+static inline uint64_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg) {
+ LDKPositiveTimestamp ret_var = PositiveTimestamp_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_PositiveTimestamp_clone_ptr(uint32_t arg) {
+ LDKPositiveTimestamp arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = PositiveTimestamp_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_PositiveTimestamp_clone(uint32_t orig) {
LDKPositiveTimestamp orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPositiveTimestamp ret_var = PositiveTimestamp_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKSha256 this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Sha256_free(this_obj_conv);
}
+static inline uint64_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg) {
+ LDKSha256 ret_var = Sha256_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Sha256_clone_ptr(uint32_t arg) {
+ LDKSha256 arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Sha256_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Sha256_clone(uint32_t orig) {
LDKSha256 orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKSha256 ret_var = Sha256_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKSha256 o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = Sha256_hash(&o_conv);
return ret_val;
}
LDKSha256 a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKSha256 b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = Sha256_eq(&a_conv, &b_conv);
return ret_val;
}
LDKDescription this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
Description_free(this_obj_conv);
}
+static inline uint64_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg) {
+ LDKDescription ret_var = Description_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Description_clone_ptr(uint32_t arg) {
+ LDKDescription arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Description_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Description_clone(uint32_t orig) {
LDKDescription orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKDescription ret_var = Description_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDescription o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = Description_hash(&o_conv);
return ret_val;
}
LDKDescription a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKDescription b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = Description_eq(&a_conv, &b_conv);
return ret_val;
}
LDKPayeePubKey this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
PayeePubKey_free(this_obj_conv);
}
LDKPayeePubKey this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), PayeePubKey_get_a(&this_ptr_conv).compressed_form, 33);
return ret_arr;
LDKPayeePubKey this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
LDKPublicKey val_ref;
CHECK(*((uint32_t*)val) == 33);
memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg) {
+ LDKPayeePubKey ret_var = PayeePubKey_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_PayeePubKey_clone_ptr(uint32_t arg) {
+ LDKPayeePubKey arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = PayeePubKey_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_PayeePubKey_clone(uint32_t orig) {
LDKPayeePubKey orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPayeePubKey ret_var = PayeePubKey_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPayeePubKey o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = PayeePubKey_hash(&o_conv);
return ret_val;
}
LDKPayeePubKey a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKPayeePubKey b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = PayeePubKey_eq(&a_conv, &b_conv);
return ret_val;
}
LDKExpiryTime this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
ExpiryTime_free(this_obj_conv);
}
+static inline uint64_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg) {
+ LDKExpiryTime ret_var = ExpiryTime_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_ExpiryTime_clone_ptr(uint32_t arg) {
+ LDKExpiryTime arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = ExpiryTime_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_ExpiryTime_clone(uint32_t orig) {
LDKExpiryTime orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKExpiryTime ret_var = ExpiryTime_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKExpiryTime o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = ExpiryTime_hash(&o_conv);
return ret_val;
}
LDKExpiryTime a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKExpiryTime b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = ExpiryTime_eq(&a_conv, &b_conv);
return ret_val;
}
LDKMinFinalCltvExpiry this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
MinFinalCltvExpiry_free(this_obj_conv);
}
LDKMinFinalCltvExpiry this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = MinFinalCltvExpiry_get_a(&this_ptr_conv);
return ret_val;
}
LDKMinFinalCltvExpiry this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
MinFinalCltvExpiry_set_a(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t MinFinalCltvExpiry_clone_ptr(LDKMinFinalCltvExpiry *NONNULL_PTR arg) {
+ LDKMinFinalCltvExpiry ret_var = MinFinalCltvExpiry_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_MinFinalCltvExpiry_clone_ptr(uint32_t arg) {
+ LDKMinFinalCltvExpiry arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = MinFinalCltvExpiry_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_MinFinalCltvExpiry_clone(uint32_t orig) {
LDKMinFinalCltvExpiry orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKMinFinalCltvExpiry ret_var = MinFinalCltvExpiry_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKMinFinalCltvExpiry o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = MinFinalCltvExpiry_hash(&o_conv);
return ret_val;
}
LDKMinFinalCltvExpiry a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKMinFinalCltvExpiry b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = MinFinalCltvExpiry_eq(&a_conv, &b_conv);
return ret_val;
}
Fallback_free(this_ptr_conv);
}
+static inline uint64_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg) {
+ LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
+ *ret_copy = Fallback_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Fallback_clone_ptr(uint32_t arg) {
+ LDKFallback* arg_conv = (LDKFallback*)arg;
+ int64_t ret_val = Fallback_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_Fallback_clone(uint32_t orig) {
LDKFallback* orig_conv = (LDKFallback*)orig;
LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
LDKInvoiceSignature this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InvoiceSignature_free(this_obj_conv);
}
+static inline uint64_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg) {
+ LDKInvoiceSignature ret_var = InvoiceSignature_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_InvoiceSignature_clone_ptr(uint32_t arg) {
+ LDKInvoiceSignature arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = InvoiceSignature_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_InvoiceSignature_clone(uint32_t orig) {
LDKInvoiceSignature orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKInvoiceSignature ret_var = InvoiceSignature_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvoiceSignature a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKInvoiceSignature b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = InvoiceSignature_eq(&a_conv, &b_conv);
return ret_val;
}
LDKPrivateRoute this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
PrivateRoute_free(this_obj_conv);
}
+static inline uint64_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg) {
+ LDKPrivateRoute ret_var = PrivateRoute_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_PrivateRoute_clone_ptr(uint32_t arg) {
+ LDKPrivateRoute arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = PrivateRoute_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_PrivateRoute_clone(uint32_t orig) {
LDKPrivateRoute orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKPrivateRoute ret_var = PrivateRoute_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKPrivateRoute o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = PrivateRoute_hash(&o_conv);
return ret_val;
}
LDKPrivateRoute a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKPrivateRoute b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = PrivateRoute_eq(&a_conv, &b_conv);
return ret_val;
}
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
this_arg_conv = SignedRawInvoice_clone(&this_arg_conv);
LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
*ret_conv = SignedRawInvoice_into_parts(this_arg_conv);
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRawInvoice ret_var = SignedRawInvoice_raw_invoice(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *SignedRawInvoice_hash(&this_arg_conv), 32);
return ret_arr;
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInvoiceSignature ret_var = SignedRawInvoice_signature(&this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
*ret_conv = SignedRawInvoice_recover_payee_pub_key(&this_arg_conv);
return (uint64_t)ret_conv;
LDKSignedRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = SignedRawInvoice_check_signature(&this_arg_conv);
return ret_val;
}
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), RawInvoice_hash(&this_arg_conv).data, 32);
return ret_arr;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKSha256 ret_var = RawInvoice_payment_hash(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKDescription ret_var = RawInvoice_description(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPayeePubKey ret_var = RawInvoice_payee_pub_key(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKSha256 ret_var = RawInvoice_description_hash(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKExpiryTime ret_var = RawInvoice_expiry_time(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKMinFinalCltvExpiry ret_var = RawInvoice_min_final_cltv_expiry(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), RawInvoice_payment_secret(&this_arg_conv).data, 32);
return ret_arr;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInvoiceFeatures ret_var = RawInvoice_features(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_PrivateRouteZ ret_var = RawInvoice_private_routes(&this_arg_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_14_ref = 0;
CHECK((((uint64_t)ret_conv_14_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_14_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
ret_conv_14_ref = (uint64_t)ret_conv_14_var.inner;
if (ret_conv_14_var.is_owned) {
ret_conv_14_ref |= 1;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = RawInvoice_amount_pico_btc(&this_arg_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKRawInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
uint32_t ret_conv = LDKCurrency_to_js(RawInvoice_currency(&this_arg_conv));
return ret_conv;
}
LDKPositiveTimestamp this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = PositiveTimestamp_as_unix_timestamp(&this_arg_conv);
return ret_val;
}
LDKPositiveTimestamp this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = PositiveTimestamp_as_time(&this_arg_conv);
return ret_val;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
this_arg_conv = Invoice_clone(&this_arg_conv);
LDKSignedRawInvoice ret_var = Invoice_into_signed_raw(this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
*ret_conv = Invoice_check_signature(&this_arg_conv);
return (uint64_t)ret_conv;
LDKSignedRawInvoice signed_invoice_conv;
signed_invoice_conv.inner = (void*)(signed_invoice & (~1));
signed_invoice_conv.is_owned = (signed_invoice & 1) || (signed_invoice == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(signed_invoice_conv);
signed_invoice_conv = SignedRawInvoice_clone(&signed_invoice_conv);
LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
*ret_conv = Invoice_from_signed(signed_invoice_conv);
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = Invoice_timestamp(&this_arg_conv);
return ret_val;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *Invoice_payment_hash(&this_arg_conv), 32);
return ret_arr;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), Invoice_payee_pub_key(&this_arg_conv).compressed_form, 33);
return ret_arr;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), *Invoice_payment_secret(&this_arg_conv), 32);
return ret_arr;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInvoiceFeatures ret_var = Invoice_features(&this_arg_conv);
uint64_t ret_ref = 0;
if ((uint64_t)ret_var.inner > 4096) {
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
memcpy((uint8_t*)(ret_arr + 4), Invoice_recover_payee_pub_key(&this_arg_conv).compressed_form, 33);
return ret_arr;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = Invoice_expiry_time(&this_arg_conv);
return ret_val;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
jboolean ret_val = Invoice_is_expired(&this_arg_conv);
return ret_val;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = Invoice_min_final_cltv_expiry(&this_arg_conv);
return ret_val;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_PrivateRouteZ ret_var = Invoice_private_routes(&this_arg_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_14_ref = 0;
CHECK((((uint64_t)ret_conv_14_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_14_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
ret_conv_14_ref = (uint64_t)ret_conv_14_var.inner;
if (ret_conv_14_var.is_owned) {
ret_conv_14_ref |= 1;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCVec_RouteHintZ ret_var = Invoice_route_hints(&this_arg_conv);
uint32_tArray ret_arr = NULL;
ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
uint64_t ret_conv_11_ref = 0;
CHECK((((uint64_t)ret_conv_11_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_conv_11_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_11_var);
ret_conv_11_ref = (uint64_t)ret_conv_11_var.inner;
if (ret_conv_11_var.is_owned) {
ret_conv_11_ref |= 1;
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
uint32_t ret_conv = LDKCurrency_to_js(Invoice_currency(&this_arg_conv));
return ret_conv;
}
LDKInvoice this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
*ret_copy = Invoice_amount_milli_satoshis(&this_arg_conv);
uint64_t ret_ref = (uint64_t)ret_copy;
LDKDescription this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
this_arg_conv = Description_clone(&this_arg_conv);
LDKStr ret_str = Description_into_inner(this_arg_conv);
jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
LDKExpiryTime this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = ExpiryTime_as_seconds(&this_arg_conv);
return ret_val;
}
LDKExpiryTime this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
int64_t ret_val = ExpiryTime_as_duration(&this_arg_conv);
return ret_val;
}
LDKRouteHint hops_conv;
hops_conv.inner = (void*)(hops & (~1));
hops_conv.is_owned = (hops & 1) || (hops == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(hops_conv);
hops_conv = RouteHint_clone(&hops_conv);
LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
*ret_conv = PrivateRoute_new(hops_conv);
LDKPrivateRoute this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
this_arg_conv = PrivateRoute_clone(&this_arg_conv);
LDKRouteHint ret_var = PrivateRoute_into_inner(this_arg_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
SignOrCreationError_free(this_ptr_conv);
}
+static inline uint64_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg) {
+ LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
+ *ret_copy = SignOrCreationError_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_SignOrCreationError_clone_ptr(uint32_t arg) {
+ LDKSignOrCreationError* arg_conv = (LDKSignOrCreationError*)arg;
+ int64_t ret_val = SignOrCreationError_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_SignOrCreationError_clone(uint32_t orig) {
LDKSignOrCreationError* orig_conv = (LDKSignOrCreationError*)orig;
LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
LDKInvoicePayer this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
InvoicePayer_free(this_obj_conv);
}
LDKRetryAttempts this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
RetryAttempts_free(this_obj_conv);
}
LDKRetryAttempts this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
int64_t ret_val = RetryAttempts_get_a(&this_ptr_conv);
return ret_val;
}
LDKRetryAttempts this_ptr_conv;
this_ptr_conv.inner = (void*)(this_ptr & (~1));
this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
RetryAttempts_set_a(&this_ptr_conv, val);
}
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
return ret_ref;
}
+static inline uint64_t RetryAttempts_clone_ptr(LDKRetryAttempts *NONNULL_PTR arg) {
+ LDKRetryAttempts ret_var = RetryAttempts_clone(arg);
+uint64_t ret_ref = 0;
+CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_RetryAttempts_clone_ptr(uint32_t arg) {
+ LDKRetryAttempts arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RetryAttempts_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_RetryAttempts_clone(uint32_t orig) {
LDKRetryAttempts orig_conv;
orig_conv.inner = (void*)(orig & (~1));
orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
LDKRetryAttempts ret_var = RetryAttempts_clone(&orig_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKRetryAttempts a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
LDKRetryAttempts b_conv;
b_conv.inner = (void*)(b & (~1));
b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
jboolean ret_val = RetryAttempts_eq(&a_conv, &b_conv);
return ret_val;
}
LDKRetryAttempts o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
int64_t ret_val = RetryAttempts_hash(&o_conv);
return ret_val;
}
PaymentError_free(this_ptr_conv);
}
+static inline uint64_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg) {
+ LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
+ *ret_copy = PaymentError_clone(arg);
+uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_PaymentError_clone_ptr(uint32_t arg) {
+ LDKPaymentError* arg_conv = (LDKPaymentError*)arg;
+ int64_t ret_val = PaymentError_clone_ptr(arg_conv);
+ return ret_val;
+}
+
uint32_t __attribute__((visibility("default"))) TS_PaymentError_clone(uint32_t orig) {
LDKPaymentError* orig_conv = (LDKPaymentError*)orig;
LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
LDKLightningError a_conv;
a_conv.inner = (void*)(a & (~1));
a_conv.is_owned = (a & 1) || (a == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
a_conv = LightningError_clone(&a_conv);
LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
*ret_copy = PaymentError_routing(a_conv);
LDKLockableScore scorer_conv;
scorer_conv.inner = (void*)(scorer & (~1));
scorer_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(scorer_conv);
void* logger_ptr = (void*)(((uint64_t)logger) & ~1);
CHECK_ACCESS(logger_ptr);
LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
LDKRetryAttempts retry_attempts_conv;
retry_attempts_conv.inner = (void*)(retry_attempts & (~1));
retry_attempts_conv.is_owned = (retry_attempts & 1) || (retry_attempts == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(retry_attempts_conv);
retry_attempts_conv = RetryAttempts_clone(&retry_attempts_conv);
LDKInvoicePayer ret_var = InvoicePayer_new(payer_conv, router_conv, &scorer_conv, logger_conv, event_handler_conv, retry_attempts_conv);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKInvoicePayer this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInvoice invoice_conv;
invoice_conv.inner = (void*)(invoice & (~1));
invoice_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
*ret_conv = InvoicePayer_pay_invoice(&this_arg_conv, &invoice_conv);
return (uint64_t)ret_conv;
LDKInvoicePayer this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKInvoice invoice_conv;
invoice_conv.inner = (void*)(invoice & (~1));
invoice_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
*ret_conv = InvoicePayer_pay_zero_value_invoice(&this_arg_conv, &invoice_conv, amount_msats);
return (uint64_t)ret_conv;
LDKInvoicePayer this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
unsigned char payment_hash_arr[32];
CHECK(*((uint32_t*)payment_hash) == 32);
memcpy(payment_hash_arr, (uint8_t*)(payment_hash + 4), 32);
LDKInvoicePayer this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKEventHandler* ret_ret = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
*ret_ret = InvoicePayer_as_EventHandler(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager channelmanager_conv;
channelmanager_conv.inner = (void*)(channelmanager & (~1));
channelmanager_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
void* keys_manager_ptr = (void*)(((uint64_t)keys_manager) & ~1);
CHECK_ACCESS(keys_manager_ptr);
LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(keys_manager_ptr);
LDKDefaultRouter this_obj_conv;
this_obj_conv.inner = (void*)(this_obj & (~1));
this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
DefaultRouter_free(this_obj_conv);
}
LDKNetworkGraph network_graph_conv;
network_graph_conv.inner = (void*)(network_graph & (~1));
network_graph_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
void* logger_ptr = (void*)(((uint64_t)logger) & ~1);
CHECK_ACCESS(logger_ptr);
LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
uint64_t ret_ref = 0;
CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
ret_ref = (uint64_t)ret_var.inner;
if (ret_var.is_owned) {
ret_ref |= 1;
LDKDefaultRouter this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKRouter* ret_ret = MALLOC(sizeof(LDKRouter), "LDKRouter");
*ret_ret = DefaultRouter_as_Router(&this_arg_conv);
return (uint64_t)ret_ret;
LDKChannelManager this_arg_conv;
this_arg_conv.inner = (void*)(this_arg & (~1));
this_arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
LDKPayer* ret_ret = MALLOC(sizeof(LDKPayer), "LDKPayer");
*ret_ret = ChannelManager_as_Payer(&this_arg_conv);
return (uint64_t)ret_ret;
LDKInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
LDKStr ret_str = Invoice_to_str(&o_conv);
jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
Str_free(ret_str);
LDKSignedRawInvoice o_conv;
o_conv.inner = (void*)(o & (~1));
o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
LDKStr ret_str = SignedRawInvoice_to_str(&o_conv);
jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
Str_free(ret_str);
public static native long new_empty_slice_vec();
*/
- public static native long LDKCVec_u8Z_new(number[] elems);
// struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)
export function TxOut_get_script_pubkey(thing: number): Uint8Array {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.TxOut_get_value(thing);
return nativeResponseValue;
}
- public static native boolean LDKCResult_SecretKeyErrorZ_result_ok(long arg);
public static native Uint8Array LDKCResult_SecretKeyErrorZ_get_ok(long arg);
public static native Secp256k1Error LDKCResult_SecretKeyErrorZ_get_err(long arg);
- public static native boolean LDKCResult_PublicKeyErrorZ_result_ok(long arg);
public static native Uint8Array LDKCResult_PublicKeyErrorZ_get_ok(long arg);
public static native Secp256k1Error LDKCResult_PublicKeyErrorZ_get_err(long arg);
- public static native boolean LDKCResult_TxCreationKeysDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_TxCreationKeysDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_TxCreationKeysDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelPublicKeysDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_ChannelPublicKeysDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_ChannelPublicKeysDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_TxCreationKeysErrorZ_result_ok(long arg);
public static native number LDKCResult_TxCreationKeysErrorZ_get_ok(long arg);
public static native Secp256k1Error LDKCResult_TxCreationKeysErrorZ_get_err(long arg);
public static class LDKCOption_u32Z {
}
static { LDKCOption_u32Z.init(); }
public static native LDKCOption_u32Z LDKCOption_u32Z_ref_from_ptr(long ptr);
- public static native boolean LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelTransactionParametersDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_ChannelTransactionParametersDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_ChannelTransactionParametersDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_HolderCommitmentTransactionDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_HolderCommitmentTransactionDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_BuiltCommitmentTransactionDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_TrustedClosingTransactionNoneZ_result_ok(long arg);
public static native number LDKCResult_TrustedClosingTransactionNoneZ_get_ok(long arg);
public static native void LDKCResult_TrustedClosingTransactionNoneZ_get_err(long arg);
- public static native boolean LDKCResult_CommitmentTransactionDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_CommitmentTransactionDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_CommitmentTransactionDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_TrustedCommitmentTransactionNoneZ_result_ok(long arg);
public static native number LDKCResult_TrustedCommitmentTransactionNoneZ_get_ok(long arg);
public static native void LDKCResult_TrustedCommitmentTransactionNoneZ_get_err(long arg);
- public static native boolean LDKCResult_CVec_SignatureZNoneZ_result_ok(long arg);
public static native Uint8Array[] LDKCResult_CVec_SignatureZNoneZ_get_ok(long arg);
public static native void LDKCResult_CVec_SignatureZNoneZ_get_err(long arg);
- public static native boolean LDKCResult_ShutdownScriptDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_ShutdownScriptDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_ShutdownScriptDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ShutdownScriptInvalidShutdownScriptZ_result_ok(long arg);
public static native number LDKCResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(long arg);
public static native number LDKCResult_ShutdownScriptInvalidShutdownScriptZ_get_err(long arg);
- public static native boolean LDKCResult_NoneErrorZ_result_ok(long arg);
public static native void LDKCResult_NoneErrorZ_get_ok(long arg);
public static native IOError LDKCResult_NoneErrorZ_get_err(long arg);
- public static native boolean LDKCResult_RouteHopDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_RouteHopDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_RouteHopDecodeErrorZ_get_err(long arg);
- public static native long LDKCVec_RouteHopZ_new(number[] elems);
- public static native boolean LDKCResult_RouteDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_RouteDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_RouteDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_RouteParametersDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_RouteParametersDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_RouteParametersDecodeErrorZ_get_err(long arg);
- public static native long LDKCVec_RouteHintZ_new(number[] elems);
public static class LDKCOption_u64Z {
private LDKCOption_u64Z() {}
export class Some extends LDKCOption_u64Z {
}
static { LDKCOption_u64Z.init(); }
public static native LDKCOption_u64Z LDKCOption_u64Z_ref_from_ptr(long ptr);
- public static native boolean LDKCResult_PayeeDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_PayeeDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_PayeeDecodeErrorZ_get_err(long arg);
- public static native long LDKCVec_RouteHintHopZ_new(number[] elems);
- public static native boolean LDKCResult_RouteHintDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_RouteHintDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_RouteHintDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_RouteHintHopDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_RouteHintHopDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_RouteHintHopDecodeErrorZ_get_err(long arg);
- public static native long LDKCVec_ChannelDetailsZ_new(number[] elems);
- public static native boolean LDKCResult_RouteLightningErrorZ_result_ok(long arg);
public static native number LDKCResult_RouteLightningErrorZ_get_ok(long arg);
public static native number LDKCResult_RouteLightningErrorZ_get_err(long arg);
- public static native boolean LDKCResult_TxOutAccessErrorZ_result_ok(long arg);
public static native number LDKCResult_TxOutAccessErrorZ_get_ok(long arg);
public static native AccessError LDKCResult_TxOutAccessErrorZ_get_err(long arg);
// uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR tuple);
const nativeResponseValue = wasm.C2Tuple_usizeTransactionZ_get_b(tuple);
return decodeArray(nativeResponseValue);
}
- public static native long LDKCVec_C2Tuple_usizeTransactionZZ_new(number[] elems);
- public static native boolean LDKCResult_NoneChannelMonitorUpdateErrZ_result_ok(long arg);
public static native void LDKCResult_NoneChannelMonitorUpdateErrZ_get_ok(long arg);
public static native ChannelMonitorUpdateErr LDKCResult_NoneChannelMonitorUpdateErrZ_get_err(long arg);
public static class LDKMonitorEvent {
}
static { LDKMonitorEvent.init(); }
public static native LDKMonitorEvent LDKMonitorEvent_ref_from_ptr(long ptr);
- public static native long LDKCVec_MonitorEventZ_new(number[] elems);
public static class LDKCOption_C2Tuple_usizeTransactionZZ {
private LDKCOption_C2Tuple_usizeTransactionZZ() {}
export class Some extends LDKCOption_C2Tuple_usizeTransactionZZ {
}
static { LDKCOption_C2Tuple_usizeTransactionZZ.init(); }
public static native LDKCOption_C2Tuple_usizeTransactionZZ LDKCOption_C2Tuple_usizeTransactionZZ_ref_from_ptr(long ptr);
+ public static class LDKClosureReason {
+ private LDKClosureReason() {}
+ export class CounterpartyForceClosed extends LDKClosureReason {
+ public String peer_msg;
+ CounterpartyForceClosed(String peer_msg) { this.peer_msg = peer_msg; }
+ }
+ export class HolderForceClosed extends LDKClosureReason {
+ HolderForceClosed() { }
+ }
+ export class CooperativeClosure extends LDKClosureReason {
+ CooperativeClosure() { }
+ }
+ export class CommitmentTxConfirmed extends LDKClosureReason {
+ CommitmentTxConfirmed() { }
+ }
+ export class ProcessingError extends LDKClosureReason {
+ public String err;
+ ProcessingError(String err) { this.err = err; }
+ }
+ export class DisconnectedPeer extends LDKClosureReason {
+ DisconnectedPeer() { }
+ }
+ export class OutdatedChannelManager extends LDKClosureReason {
+ OutdatedChannelManager() { }
+ }
+ static native void init();
+ }
+ static { LDKClosureReason.init(); }
+ public static native LDKClosureReason LDKClosureReason_ref_from_ptr(long ptr);
+ public static class LDKCOption_ClosureReasonZ {
+ private LDKCOption_ClosureReasonZ() {}
+ export class Some extends LDKCOption_ClosureReasonZ {
+ public number some;
+ Some(number some) { this.some = some; }
+ }
+ export class None extends LDKCOption_ClosureReasonZ {
+ None() { }
+ }
+ static native void init();
+ }
+ static { LDKCOption_ClosureReasonZ.init(); }
+ public static native LDKCOption_ClosureReasonZ LDKCOption_ClosureReasonZ_ref_from_ptr(long ptr);
+ public static native number LDKCResult_COption_ClosureReasonZDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_COption_ClosureReasonZDecodeErrorZ_get_err(long arg);
public static class LDKNetworkUpdate {
private LDKNetworkUpdate() {}
export class ChannelUpdateMessage extends LDKNetworkUpdate {
}
static { LDKSpendableOutputDescriptor.init(); }
public static native LDKSpendableOutputDescriptor LDKSpendableOutputDescriptor_ref_from_ptr(long ptr);
- public static native long LDKCVec_SpendableOutputDescriptorZ_new(number[] elems);
+ public static class LDKPaymentPurpose {
+ private LDKPaymentPurpose() {}
+ export class InvoicePayment extends LDKPaymentPurpose {
+ public Uint8Array payment_preimage;
+ public Uint8Array payment_secret;
+ public number user_payment_id;
+ InvoicePayment(Uint8Array payment_preimage, Uint8Array payment_secret, number user_payment_id) { this.payment_preimage = payment_preimage; this.payment_secret = payment_secret; this.user_payment_id = user_payment_id; }
+ }
+ export class SpontaneousPayment extends LDKPaymentPurpose {
+ public Uint8Array spontaneous_payment;
+ SpontaneousPayment(Uint8Array spontaneous_payment) { this.spontaneous_payment = spontaneous_payment; }
+ }
+ static native void init();
+ }
+ static { LDKPaymentPurpose.init(); }
+ public static native LDKPaymentPurpose LDKPaymentPurpose_ref_from_ptr(long ptr);
+ public static class LDKEvent {
+ private LDKEvent() {}
+ export class FundingGenerationReady extends LDKEvent {
+ public Uint8Array temporary_channel_id;
+ public number channel_value_satoshis;
+ public Uint8Array output_script;
+ public number user_channel_id;
+ FundingGenerationReady(Uint8Array temporary_channel_id, number channel_value_satoshis, Uint8Array output_script, number user_channel_id) { this.temporary_channel_id = temporary_channel_id; this.channel_value_satoshis = channel_value_satoshis; this.output_script = output_script; this.user_channel_id = user_channel_id; }
+ }
+ export class PaymentReceived extends LDKEvent {
+ public Uint8Array payment_hash;
+ public number amt;
+ public number purpose;
+ PaymentReceived(Uint8Array payment_hash, number amt, number purpose) { this.payment_hash = payment_hash; this.amt = amt; this.purpose = purpose; }
+ }
+ export class PaymentSent extends LDKEvent {
+ public Uint8Array payment_id;
+ public Uint8Array payment_preimage;
+ public Uint8Array payment_hash;
+ public number fee_paid_msat;
+ PaymentSent(Uint8Array payment_id, Uint8Array payment_preimage, Uint8Array payment_hash, number fee_paid_msat) { this.payment_id = payment_id; this.payment_preimage = payment_preimage; this.payment_hash = payment_hash; this.fee_paid_msat = fee_paid_msat; }
+ }
+ export class PaymentPathFailed extends LDKEvent {
+ public Uint8Array payment_id;
+ public Uint8Array payment_hash;
+ public boolean rejected_by_dest;
+ public number network_update;
+ public boolean all_paths_failed;
+ public number[] path;
+ public number short_channel_id;
+ public number retry;
+ PaymentPathFailed(Uint8Array payment_id, Uint8Array payment_hash, boolean rejected_by_dest, number network_update, boolean all_paths_failed, number[] path, number short_channel_id, number retry) { this.payment_id = payment_id; this.payment_hash = payment_hash; this.rejected_by_dest = rejected_by_dest; this.network_update = network_update; this.all_paths_failed = all_paths_failed; this.path = path; this.short_channel_id = short_channel_id; this.retry = retry; }
+ }
+ export class PendingHTLCsForwardable extends LDKEvent {
+ public number time_forwardable;
+ PendingHTLCsForwardable(number time_forwardable) { this.time_forwardable = time_forwardable; }
+ }
+ export class SpendableOutputs extends LDKEvent {
+ public number[] outputs;
+ SpendableOutputs(number[] outputs) { this.outputs = outputs; }
+ }
+ export class PaymentForwarded extends LDKEvent {
+ public number fee_earned_msat;
+ public boolean claim_from_onchain_tx;
+ PaymentForwarded(number fee_earned_msat, boolean claim_from_onchain_tx) { this.fee_earned_msat = fee_earned_msat; this.claim_from_onchain_tx = claim_from_onchain_tx; }
+ }
+ export class ChannelClosed extends LDKEvent {
+ public Uint8Array channel_id;
+ public number user_channel_id;
+ public number reason;
+ ChannelClosed(Uint8Array channel_id, number user_channel_id, number reason) { this.channel_id = channel_id; this.user_channel_id = user_channel_id; this.reason = reason; }
+ }
+ export class DiscardFunding extends LDKEvent {
+ public Uint8Array channel_id;
+ public Uint8Array transaction;
+ DiscardFunding(Uint8Array channel_id, Uint8Array transaction) { this.channel_id = channel_id; this.transaction = transaction; }
+ }
+ static native void init();
+ }
+ static { LDKEvent.init(); }
+ public static native LDKEvent LDKEvent_ref_from_ptr(long ptr);
+ public static class LDKCOption_EventZ {
+ private LDKCOption_EventZ() {}
+ export class Some extends LDKCOption_EventZ {
+ public number some;
+ Some(number some) { this.some = some; }
+ }
+ export class None extends LDKCOption_EventZ {
+ None() { }
+ }
+ static native void init();
+ }
+ static { LDKCOption_EventZ.init(); }
+ public static native LDKCOption_EventZ LDKCOption_EventZ_ref_from_ptr(long ptr);
+ public static native number LDKCResult_COption_EventZDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_COption_EventZDecodeErrorZ_get_err(long arg);
public static class LDKErrorAction {
private LDKErrorAction() {}
export class DisconnectPeer extends LDKErrorAction {
}
static { LDKMessageSendEvent.init(); }
public static native LDKMessageSendEvent LDKMessageSendEvent_ref_from_ptr(long ptr);
- public static native long LDKCVec_MessageSendEventZ_new(number[] elems);
- public static native boolean LDKCResult_InitFeaturesDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_InitFeaturesDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_InitFeaturesDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NodeFeaturesDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_NodeFeaturesDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_NodeFeaturesDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelFeaturesDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_ChannelFeaturesDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_ChannelFeaturesDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_InvoiceFeaturesDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_InvoiceFeaturesDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_InvoiceFeaturesDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ScoringParametersDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_ScoringParametersDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_ScoringParametersDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ScorerDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_ScorerDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_ScorerDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_SpendableOutputDescriptorDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_SpendableOutputDescriptorDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NoneNoneZ_result_ok(long arg);
public static native void LDKCResult_NoneNoneZ_get_ok(long arg);
public static native void LDKCResult_NoneNoneZ_get_err(long arg);
// struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR tuple);
const nativeResponseValue = wasm.C2Tuple_SignatureCVec_SignatureZZ_get_b(tuple);
return nativeResponseValue;
}
- public static native boolean LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_result_ok(long arg);
public static native number LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(long arg);
public static native void LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(long arg);
- public static native boolean LDKCResult_SignatureNoneZ_result_ok(long arg);
public static native Uint8Array LDKCResult_SignatureNoneZ_get_ok(long arg);
public static native void LDKCResult_SignatureNoneZ_get_err(long arg);
const nativeResponseValue = wasm.Sign_write(this_arg);
return decodeArray(nativeResponseValue);
}
- public static native boolean LDKCResult_SignDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_SignDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_SignDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_RecoverableSignatureNoneZ_result_ok(long arg);
public static native Uint8Array LDKCResult_RecoverableSignatureNoneZ_get_ok(long arg);
public static native void LDKCResult_RecoverableSignatureNoneZ_get_err(long arg);
- public static native boolean LDKCResult_CVec_CVec_u8ZZNoneZ_result_ok(long arg);
public static native Uint8Array[] LDKCResult_CVec_CVec_u8ZZNoneZ_get_ok(long arg);
public static native void LDKCResult_CVec_CVec_u8ZZNoneZ_get_err(long arg);
- public static native boolean LDKCResult_InMemorySignerDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_InMemorySignerDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_InMemorySignerDecodeErrorZ_get_err(long arg);
- public static native long LDKCVec_TxOutZ_new(number[] elems);
- public static native boolean LDKCResult_TransactionNoneZ_result_ok(long arg);
public static native Uint8Array LDKCResult_TransactionNoneZ_get_ok(long arg);
public static native void LDKCResult_TransactionNoneZ_get_err(long arg);
// struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR tuple);
const nativeResponseValue = wasm.C2Tuple_BlockHashChannelMonitorZ_get_b(tuple);
return nativeResponseValue;
}
- public static native long LDKCVec_C2Tuple_BlockHashChannelMonitorZZ_new(number[] elems);
- public static native boolean LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_result_ok(long arg);
public static native number[] LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_get_ok(long arg);
public static native IOError LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_get_err(long arg);
public static class LDKCOption_u16Z {
}
static { LDKAPIError.init(); }
public static native LDKAPIError LDKAPIError_ref_from_ptr(long ptr);
- public static native boolean LDKCResult_NoneAPIErrorZ_result_ok(long arg);
public static native void LDKCResult_NoneAPIErrorZ_get_ok(long arg);
public static native number LDKCResult_NoneAPIErrorZ_get_err(long arg);
- public static native long LDKCVec_CResult_NoneAPIErrorZZ_new(number[] elems);
- public static native long LDKCVec_APIErrorZ_new(number[] elems);
- public static native boolean LDKCResult__u832APIErrorZ_result_ok(long arg);
public static native Uint8Array LDKCResult__u832APIErrorZ_get_ok(long arg);
public static native number LDKCResult__u832APIErrorZ_get_err(long arg);
public static class LDKPaymentSendFailure {
}
static { LDKPaymentSendFailure.init(); }
public static native LDKPaymentSendFailure LDKPaymentSendFailure_ref_from_ptr(long ptr);
- public static native boolean LDKCResult_PaymentIdPaymentSendFailureZ_result_ok(long arg);
public static native Uint8Array LDKCResult_PaymentIdPaymentSendFailureZ_get_ok(long arg);
public static native number LDKCResult_PaymentIdPaymentSendFailureZ_get_err(long arg);
- public static native boolean LDKCResult_NonePaymentSendFailureZ_result_ok(long arg);
public static native void LDKCResult_NonePaymentSendFailureZ_get_ok(long arg);
public static native number LDKCResult_NonePaymentSendFailureZ_get_err(long arg);
// struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR tuple);
const nativeResponseValue = wasm.C2Tuple_PaymentHashPaymentIdZ_get_b(tuple);
return decodeArray(nativeResponseValue);
}
- public static native boolean LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_result_ok(long arg);
public static native number LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(long arg);
public static native number LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(long arg);
public static class LDKNetAddress {
}
static { LDKNetAddress.init(); }
public static native LDKNetAddress LDKNetAddress_ref_from_ptr(long ptr);
- public static native long LDKCVec_NetAddressZ_new(number[] elems);
// struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR tuple);
export function C2Tuple_PaymentHashPaymentSecretZ_get_a(tuple: number): Uint8Array {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.C2Tuple_PaymentHashPaymentSecretZ_get_b(tuple);
return decodeArray(nativeResponseValue);
}
- public static native boolean LDKCResult_PaymentSecretAPIErrorZ_result_ok(long arg);
public static native Uint8Array LDKCResult_PaymentSecretAPIErrorZ_get_ok(long arg);
public static native number LDKCResult_PaymentSecretAPIErrorZ_get_err(long arg);
- public static native long LDKCVec_ChannelMonitorZ_new(number[] elems);
// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
export interface LDKLogger {
- log (record: String): void;
+ log (record: number): void;
}
export function LDKLogger_new(impl: LDKLogger): number {
const nativeResponseValue = wasm.C2Tuple_BlockHashChannelManagerZ_get_b(tuple);
return nativeResponseValue;
}
- public static native boolean LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelConfigDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_ChannelConfigDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_ChannelConfigDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_OutPointDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_OutPointDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_OutPointDecodeErrorZ_get_err(long arg);
}
static { LDKCOption_TypeZ.init(); }
public static native LDKCOption_TypeZ LDKCOption_TypeZ_ref_from_ptr(long ptr);
- public static native boolean LDKCResult_COption_TypeZDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_COption_TypeZDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_COption_TypeZDecodeErrorZ_get_err(long arg);
public static class LDKPaymentError {
}
static { LDKPaymentError.init(); }
public static native LDKPaymentError LDKPaymentError_ref_from_ptr(long ptr);
- public static native boolean LDKCResult_PaymentIdPaymentErrorZ_result_ok(long arg);
public static native Uint8Array LDKCResult_PaymentIdPaymentErrorZ_get_ok(long arg);
public static native number LDKCResult_PaymentIdPaymentErrorZ_get_err(long arg);
- public static native boolean LDKCResult_SiPrefixNoneZ_result_ok(long arg);
public static native SiPrefix LDKCResult_SiPrefixNoneZ_get_ok(long arg);
public static native void LDKCResult_SiPrefixNoneZ_get_err(long arg);
- public static native boolean LDKCResult_InvoiceNoneZ_result_ok(long arg);
public static native number LDKCResult_InvoiceNoneZ_get_ok(long arg);
public static native void LDKCResult_InvoiceNoneZ_get_err(long arg);
- public static native boolean LDKCResult_SignedRawInvoiceNoneZ_result_ok(long arg);
public static native number LDKCResult_SignedRawInvoiceNoneZ_get_ok(long arg);
public static native void LDKCResult_SignedRawInvoiceNoneZ_get_err(long arg);
// struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR tuple);
const nativeResponseValue = wasm.C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(tuple);
return nativeResponseValue;
}
- public static native boolean LDKCResult_PayeePubKeyErrorZ_result_ok(long arg);
public static native number LDKCResult_PayeePubKeyErrorZ_get_ok(long arg);
public static native Secp256k1Error LDKCResult_PayeePubKeyErrorZ_get_err(long arg);
- public static native long LDKCVec_PrivateRouteZ_new(number[] elems);
- public static native boolean LDKCResult_PositiveTimestampCreationErrorZ_result_ok(long arg);
public static native number LDKCResult_PositiveTimestampCreationErrorZ_get_ok(long arg);
public static native CreationError LDKCResult_PositiveTimestampCreationErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NoneSemanticErrorZ_result_ok(long arg);
public static native void LDKCResult_NoneSemanticErrorZ_get_ok(long arg);
public static native SemanticError LDKCResult_NoneSemanticErrorZ_get_err(long arg);
- public static native boolean LDKCResult_InvoiceSemanticErrorZ_result_ok(long arg);
public static native number LDKCResult_InvoiceSemanticErrorZ_get_ok(long arg);
public static native SemanticError LDKCResult_InvoiceSemanticErrorZ_get_err(long arg);
- public static native boolean LDKCResult_DescriptionCreationErrorZ_result_ok(long arg);
public static native number LDKCResult_DescriptionCreationErrorZ_get_ok(long arg);
public static native CreationError LDKCResult_DescriptionCreationErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ExpiryTimeCreationErrorZ_result_ok(long arg);
public static native number LDKCResult_ExpiryTimeCreationErrorZ_get_ok(long arg);
public static native CreationError LDKCResult_ExpiryTimeCreationErrorZ_get_err(long arg);
- public static native boolean LDKCResult_PrivateRouteCreationErrorZ_result_ok(long arg);
public static native number LDKCResult_PrivateRouteCreationErrorZ_get_ok(long arg);
public static native CreationError LDKCResult_PrivateRouteCreationErrorZ_get_err(long arg);
- public static native boolean LDKCResult_StringErrorZ_result_ok(long arg);
public static native String LDKCResult_StringErrorZ_get_ok(long arg);
public static native Secp256k1Error LDKCResult_StringErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelMonitorUpdateDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_ChannelMonitorUpdateDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_HTLCUpdateDecodeErrorZ_result_ok(long arg);
+ public static class LDKCOption_MonitorEventZ {
+ private LDKCOption_MonitorEventZ() {}
+ export class Some extends LDKCOption_MonitorEventZ {
+ public number some;
+ Some(number some) { this.some = some; }
+ }
+ export class None extends LDKCOption_MonitorEventZ {
+ None() { }
+ }
+ static native void init();
+ }
+ static { LDKCOption_MonitorEventZ.init(); }
+ public static native LDKCOption_MonitorEventZ LDKCOption_MonitorEventZ_ref_from_ptr(long ptr);
+ public static native number LDKCResult_COption_MonitorEventZDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_COption_MonitorEventZDecodeErrorZ_get_err(long arg);
public static native number LDKCResult_HTLCUpdateDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_HTLCUpdateDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NoneMonitorUpdateErrorZ_result_ok(long arg);
public static native void LDKCResult_NoneMonitorUpdateErrorZ_get_ok(long arg);
public static native number LDKCResult_NoneMonitorUpdateErrorZ_get_err(long arg);
// struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR tuple);
const nativeResponseValue = wasm.C2Tuple_u32ScriptZ_get_b(tuple);
return decodeArray(nativeResponseValue);
}
- public static native long LDKCVec_C2Tuple_u32ScriptZZ_new(number[] elems);
// struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR tuple);
export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(tuple: number): Uint8Array {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(tuple);
return nativeResponseValue;
}
- public static native long LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_new(number[] elems);
- public static class LDKPaymentPurpose {
- private LDKPaymentPurpose() {}
- export class InvoicePayment extends LDKPaymentPurpose {
- public Uint8Array payment_preimage;
- public Uint8Array payment_secret;
- public number user_payment_id;
- InvoicePayment(Uint8Array payment_preimage, Uint8Array payment_secret, number user_payment_id) { this.payment_preimage = payment_preimage; this.payment_secret = payment_secret; this.user_payment_id = user_payment_id; }
- }
- export class SpontaneousPayment extends LDKPaymentPurpose {
- public Uint8Array spontaneous_payment;
- SpontaneousPayment(Uint8Array spontaneous_payment) { this.spontaneous_payment = spontaneous_payment; }
- }
- static native void init();
- }
- static { LDKPaymentPurpose.init(); }
- public static native LDKPaymentPurpose LDKPaymentPurpose_ref_from_ptr(long ptr);
- public static class LDKClosureReason {
- private LDKClosureReason() {}
- export class CounterpartyForceClosed extends LDKClosureReason {
- public String peer_msg;
- CounterpartyForceClosed(String peer_msg) { this.peer_msg = peer_msg; }
- }
- export class HolderForceClosed extends LDKClosureReason {
- HolderForceClosed() { }
- }
- export class CooperativeClosure extends LDKClosureReason {
- CooperativeClosure() { }
- }
- export class CommitmentTxConfirmed extends LDKClosureReason {
- CommitmentTxConfirmed() { }
- }
- export class ProcessingError extends LDKClosureReason {
- public String err;
- ProcessingError(String err) { this.err = err; }
- }
- export class DisconnectedPeer extends LDKClosureReason {
- DisconnectedPeer() { }
- }
- export class OutdatedChannelManager extends LDKClosureReason {
- OutdatedChannelManager() { }
- }
- static native void init();
- }
- static { LDKClosureReason.init(); }
- public static native LDKClosureReason LDKClosureReason_ref_from_ptr(long ptr);
- public static class LDKEvent {
- private LDKEvent() {}
- export class FundingGenerationReady extends LDKEvent {
- public Uint8Array temporary_channel_id;
- public number channel_value_satoshis;
- public Uint8Array output_script;
- public number user_channel_id;
- FundingGenerationReady(Uint8Array temporary_channel_id, number channel_value_satoshis, Uint8Array output_script, number user_channel_id) { this.temporary_channel_id = temporary_channel_id; this.channel_value_satoshis = channel_value_satoshis; this.output_script = output_script; this.user_channel_id = user_channel_id; }
- }
- export class PaymentReceived extends LDKEvent {
- public Uint8Array payment_hash;
- public number amt;
- public number purpose;
- PaymentReceived(Uint8Array payment_hash, number amt, number purpose) { this.payment_hash = payment_hash; this.amt = amt; this.purpose = purpose; }
- }
- export class PaymentSent extends LDKEvent {
- public Uint8Array payment_id;
- public Uint8Array payment_preimage;
- public Uint8Array payment_hash;
- public number fee_paid_msat;
- PaymentSent(Uint8Array payment_id, Uint8Array payment_preimage, Uint8Array payment_hash, number fee_paid_msat) { this.payment_id = payment_id; this.payment_preimage = payment_preimage; this.payment_hash = payment_hash; this.fee_paid_msat = fee_paid_msat; }
- }
- export class PaymentPathFailed extends LDKEvent {
- public Uint8Array payment_id;
- public Uint8Array payment_hash;
- public boolean rejected_by_dest;
- public number network_update;
- public boolean all_paths_failed;
- public number[] path;
- public number short_channel_id;
- public number retry;
- PaymentPathFailed(Uint8Array payment_id, Uint8Array payment_hash, boolean rejected_by_dest, number network_update, boolean all_paths_failed, number[] path, number short_channel_id, number retry) { this.payment_id = payment_id; this.payment_hash = payment_hash; this.rejected_by_dest = rejected_by_dest; this.network_update = network_update; this.all_paths_failed = all_paths_failed; this.path = path; this.short_channel_id = short_channel_id; this.retry = retry; }
- }
- export class PendingHTLCsForwardable extends LDKEvent {
- public number time_forwardable;
- PendingHTLCsForwardable(number time_forwardable) { this.time_forwardable = time_forwardable; }
- }
- export class SpendableOutputs extends LDKEvent {
- public number[] outputs;
- SpendableOutputs(number[] outputs) { this.outputs = outputs; }
- }
- export class PaymentForwarded extends LDKEvent {
- public number fee_earned_msat;
- public boolean claim_from_onchain_tx;
- PaymentForwarded(number fee_earned_msat, boolean claim_from_onchain_tx) { this.fee_earned_msat = fee_earned_msat; this.claim_from_onchain_tx = claim_from_onchain_tx; }
- }
- export class ChannelClosed extends LDKEvent {
- public Uint8Array channel_id;
- public number user_channel_id;
- public number reason;
- ChannelClosed(Uint8Array channel_id, number user_channel_id, number reason) { this.channel_id = channel_id; this.user_channel_id = user_channel_id; this.reason = reason; }
- }
- export class DiscardFunding extends LDKEvent {
- public Uint8Array channel_id;
- public Uint8Array transaction;
- DiscardFunding(Uint8Array channel_id, Uint8Array transaction) { this.channel_id = channel_id; this.transaction = transaction; }
- }
- static native void init();
- }
- static { LDKEvent.init(); }
- public static native LDKEvent LDKEvent_ref_from_ptr(long ptr);
- public static native long LDKCVec_EventZ_new(number[] elems);
// uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR tuple);
export function C2Tuple_u32TxOutZ_get_a(tuple: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.C2Tuple_u32TxOutZ_get_b(tuple);
return nativeResponseValue;
}
- public static native long LDKCVec_C2Tuple_u32TxOutZZ_new(number[] elems);
// struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR tuple);
export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(tuple: number): Uint8Array {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(tuple);
return nativeResponseValue;
}
- public static native long LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_new(number[] elems);
public static class LDKBalance {
private LDKBalance() {}
export class ClaimableOnChannelClose extends LDKBalance {
}
static { LDKBalance.init(); }
public static native LDKBalance LDKBalance_ref_from_ptr(long ptr);
- public static native long LDKCVec_BalanceZ_new(number[] elems);
- public static native boolean LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NoneLightningErrorZ_result_ok(long arg);
public static native void LDKCResult_NoneLightningErrorZ_get_ok(long arg);
public static native number LDKCResult_NoneLightningErrorZ_get_err(long arg);
// struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR tuple);
const nativeResponseValue = wasm.C2Tuple_PublicKeyTypeZ_get_b(tuple);
return nativeResponseValue;
}
- public static native long LDKCVec_C2Tuple_PublicKeyTypeZZ_new(number[] elems);
- public static native boolean LDKCResult_boolLightningErrorZ_result_ok(long arg);
public static native boolean LDKCResult_boolLightningErrorZ_get_ok(long arg);
public static native number LDKCResult_boolLightningErrorZ_get_err(long arg);
// struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR tuple);
const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(tuple);
return nativeResponseValue;
}
- public static native long LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_new(number[] elems);
- public static native long LDKCVec_NodeAnnouncementZ_new(number[] elems);
- public static native boolean LDKCResult_CVec_u8ZPeerHandleErrorZ_result_ok(long arg);
public static native Uint8Array LDKCResult_CVec_u8ZPeerHandleErrorZ_get_ok(long arg);
public static native number LDKCResult_CVec_u8ZPeerHandleErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NonePeerHandleErrorZ_result_ok(long arg);
public static native void LDKCResult_NonePeerHandleErrorZ_get_ok(long arg);
public static native number LDKCResult_NonePeerHandleErrorZ_get_err(long arg);
- public static native boolean LDKCResult_boolPeerHandleErrorZ_result_ok(long arg);
public static native boolean LDKCResult_boolPeerHandleErrorZ_get_ok(long arg);
public static native number LDKCResult_boolPeerHandleErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NodeIdDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_NodeIdDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_NodeIdDecodeErrorZ_get_err(long arg);
+ public static native number LDKCResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_COption_NetworkUpdateZDecodeErrorZ_get_err(long arg);
}
static { LDKCOption_AccessZ.init(); }
public static native LDKCOption_AccessZ LDKCOption_AccessZ_ref_from_ptr(long ptr);
- public static native boolean LDKCResult_DirectionalChannelInfoDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelInfoDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_ChannelInfoDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_ChannelInfoDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_RoutingFeesDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_RoutingFeesDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_RoutingFeesDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NodeAnnouncementInfoDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_NodeAnnouncementInfoDecodeErrorZ_get_err(long arg);
- public static native long LDKCVec_u64Z_new(number[] elems);
- public static native boolean LDKCResult_NodeInfoDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_NodeInfoDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_NodeInfoDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NetworkGraphDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_NetworkGraphDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_NetworkGraphDecodeErrorZ_get_err(long arg);
public static class LDKCOption_CVec_NetAddressZZ {
}
static { LDKCOption_CVec_NetAddressZZ.init(); }
public static native LDKCOption_CVec_NetAddressZZ LDKCOption_CVec_NetAddressZZ_ref_from_ptr(long ptr);
- public static native boolean LDKCResult_NetAddressDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_NetAddressDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_NetAddressDecodeErrorZ_get_err(long arg);
- public static native long LDKCVec_UpdateAddHTLCZ_new(number[] elems);
- public static native long LDKCVec_UpdateFulfillHTLCZ_new(number[] elems);
- public static native long LDKCVec_UpdateFailHTLCZ_new(number[] elems);
- public static native long LDKCVec_UpdateFailMalformedHTLCZ_new(number[] elems);
- public static native boolean LDKCResult_AcceptChannelDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_AcceptChannelDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_AcceptChannelDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_AnnouncementSignaturesDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_AnnouncementSignaturesDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_AnnouncementSignaturesDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelReestablishDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_ChannelReestablishDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_ChannelReestablishDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ClosingSignedDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_ClosingSignedDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_ClosingSignedDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ClosingSignedFeeRangeDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_CommitmentSignedDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_CommitmentSignedDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_CommitmentSignedDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_FundingCreatedDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_FundingCreatedDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_FundingCreatedDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_FundingSignedDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_FundingSignedDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_FundingSignedDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_FundingLockedDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_FundingLockedDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_FundingLockedDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_InitDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_InitDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_InitDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_OpenChannelDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_OpenChannelDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_OpenChannelDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_RevokeAndACKDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_RevokeAndACKDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_RevokeAndACKDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ShutdownDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_ShutdownDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_ShutdownDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UpdateFailHTLCDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_UpdateFailHTLCDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_UpdateFailHTLCDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UpdateFeeDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_UpdateFeeDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_UpdateFeeDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UpdateFulfillHTLCDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_UpdateFulfillHTLCDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UpdateAddHTLCDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_UpdateAddHTLCDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_UpdateAddHTLCDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_PingDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_PingDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_PingDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_PongDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_PongDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_PongDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelAnnouncementDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_ChannelAnnouncementDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_ChannelAnnouncementDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UnsignedChannelUpdateDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_UnsignedChannelUpdateDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelUpdateDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_ChannelUpdateDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_ChannelUpdateDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ErrorMessageDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_ErrorMessageDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_ErrorMessageDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NodeAnnouncementDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_NodeAnnouncementDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_NodeAnnouncementDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_QueryShortChannelIdsDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_QueryShortChannelIdsDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_QueryShortChannelIdsDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_QueryChannelRangeDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_QueryChannelRangeDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_QueryChannelRangeDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ReplyChannelRangeDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_ReplyChannelRangeDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_ReplyChannelRangeDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_GossipTimestampFilterDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_GossipTimestampFilterDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_GossipTimestampFilterDecodeErrorZ_get_err(long arg);
public static class LDKSignOrCreationError {
}
static { LDKSignOrCreationError.init(); }
public static native LDKSignOrCreationError LDKSignOrCreationError_ref_from_ptr(long ptr);
- public static native boolean LDKCResult_InvoiceSignOrCreationErrorZ_result_ok(long arg);
public static native number LDKCResult_InvoiceSignOrCreationErrorZ_get_ok(long arg);
public static native number LDKCResult_InvoiceSignOrCreationErrorZ_get_err(long arg);
}
static { LDKCOption_FilterZ.init(); }
public static native LDKCOption_FilterZ LDKCOption_FilterZ_ref_from_ptr(long ptr);
- public static native boolean LDKCResult_LockedChannelMonitorNoneZ_result_ok(long arg);
public static native number LDKCResult_LockedChannelMonitorNoneZ_get_ok(long arg);
public static native void LDKCResult_LockedChannelMonitorNoneZ_get_err(long arg);
- public static native long LDKCVec_OutPointZ_new(number[] elems);
const nativeResponseValue = wasm.TxOut_free(_res);
// debug statements here
}
+ // uint64_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
+ export function TxOut_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TxOut_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
export function TxOut_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_SecretKeyErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_SecretKeyErrorZ_is_ok(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR o);
+ export function CResult_SecretKeyErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_SecretKeyErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_SecretKeyErrorZ_free(struct LDKCResult_SecretKeyErrorZ _res);
export function CResult_SecretKeyErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_PublicKeyErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_PublicKeyErrorZ_is_ok(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR o);
+ export function CResult_PublicKeyErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PublicKeyErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
export function CResult_PublicKeyErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_PublicKeyErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg);
+ export function CResult_PublicKeyErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PublicKeyErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_clone(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR orig);
export function CResult_PublicKeyErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_TxCreationKeysDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
- export function CResult_TxCreationKeysDecodeErrorZ_free(_res: number): void {
+ // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_TxCreationKeysDecodeErrorZ_is_ok(o: number): boolean {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_TxCreationKeysDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_TxCreationKeysDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
+ // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
+ export function CResult_TxCreationKeysDecodeErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_TxCreationKeysDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
export function CResult_TxCreationKeysDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ChannelPublicKeysDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
export function CResult_ChannelPublicKeysDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ChannelPublicKeysDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
export function CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_TxCreationKeysErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_TxCreationKeysErrorZ_is_ok(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR o);
+ export function CResult_TxCreationKeysErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_TxCreationKeysErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_TxCreationKeysErrorZ_free(struct LDKCResult_TxCreationKeysErrorZ _res);
export function CResult_TxCreationKeysErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_TxCreationKeysErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_TxCreationKeysErrorZ_clone_ptr(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR arg);
+ export function CResult_TxCreationKeysErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_TxCreationKeysErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_clone(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR orig);
export function CResult_TxCreationKeysErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.COption_u32Z_free(_res);
// debug statements here
}
+ // uint64_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
+ export function COption_u32Z_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_u32Z_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
export function COption_u32Z_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
export function CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ChannelTransactionParametersDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
export function CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ChannelTransactionParametersDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
export function CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_HolderCommitmentTransactionDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
export function CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
export function CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_TrustedClosingTransactionNoneZ_err();
return nativeResponseValue;
}
+ // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
+ export function CResult_TrustedClosingTransactionNoneZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_TrustedClosingTransactionNoneZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
export function CResult_TrustedClosingTransactionNoneZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_CommitmentTransactionDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_CommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CommitmentTransactionDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
export function CResult_CommitmentTransactionDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_CommitmentTransactionDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
export function CResult_CommitmentTransactionDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_TrustedCommitmentTransactionNoneZ_err();
return nativeResponseValue;
}
+ // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
+ export function CResult_TrustedCommitmentTransactionNoneZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_TrustedCommitmentTransactionNoneZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_CVec_SignatureZNoneZ_err();
return nativeResponseValue;
}
+ // bool CResult_CVec_SignatureZNoneZ_is_ok(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR o);
+ export function CResult_CVec_SignatureZNoneZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CVec_SignatureZNoneZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
export function CResult_CVec_SignatureZNoneZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_CVec_SignatureZNoneZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg);
+ export function CResult_CVec_SignatureZNoneZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CVec_SignatureZNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
export function CResult_CVec_SignatureZNoneZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ShutdownScriptDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_ShutdownScriptDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ShutdownScriptDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
export function CResult_ShutdownScriptDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ShutdownScriptDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
+ export function CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
+ export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NoneErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_NoneErrorZ_is_ok(const struct LDKCResult_NoneErrorZ *NONNULL_PTR o);
+ export function CResult_NoneErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_NoneErrorZ_free(struct LDKCResult_NoneErrorZ _res);
export function CResult_NoneErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NoneErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg);
+ export function CResult_NoneErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_clone(const struct LDKCResult_NoneErrorZ *NONNULL_PTR orig);
export function CResult_NoneErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_RouteHopDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_RouteHopDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_RouteHopDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
export function CResult_RouteHopDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_RouteHopDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
export function CResult_RouteHopDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_RouteDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_RouteDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_RouteDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
export function CResult_RouteDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_RouteDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_RouteDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_RouteDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
export function CResult_RouteDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_RouteParametersDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_RouteParametersDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_RouteParametersDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
export function CResult_RouteParametersDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_RouteParametersDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
export function CResult_RouteParametersDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.COption_u64Z_free(_res);
// debug statements here
}
+ // uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
+ export function COption_u64Z_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_u64Z_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
export function COption_u64Z_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_PayeeDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_PayeeDecodeErrorZ_is_ok(const struct LDKCResult_PayeeDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_PayeeDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PayeeDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_PayeeDecodeErrorZ_free(struct LDKCResult_PayeeDecodeErrorZ _res);
export function CResult_PayeeDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_PayeeDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_PayeeDecodeErrorZ_clone_ptr(LDKCResult_PayeeDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_PayeeDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PayeeDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_PayeeDecodeErrorZ CResult_PayeeDecodeErrorZ_clone(const struct LDKCResult_PayeeDecodeErrorZ *NONNULL_PTR orig);
export function CResult_PayeeDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_RouteHintDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_RouteHintDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_RouteHintDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
export function CResult_RouteHintDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_RouteHintDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
export function CResult_RouteHintDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_RouteHintHopDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_RouteHintHopDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
export function CResult_RouteHintHopDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_RouteHintHopDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
export function CResult_RouteHintHopDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_RouteLightningErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
+ export function CResult_RouteLightningErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_RouteLightningErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
export function CResult_RouteLightningErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_RouteLightningErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
+ export function CResult_RouteLightningErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_RouteLightningErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
export function CResult_RouteLightningErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_TxOutAccessErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_TxOutAccessErrorZ_is_ok(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR o);
+ export function CResult_TxOutAccessErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_TxOutAccessErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
export function CResult_TxOutAccessErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_TxOutAccessErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg);
+ export function CResult_TxOutAccessErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_TxOutAccessErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
export function CResult_TxOutAccessErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_TxOutAccessErrorZ_clone(orig);
return nativeResponseValue;
}
+ // uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
+ export function C2Tuple_usizeTransactionZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_usizeTransactionZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
export function C2Tuple_usizeTransactionZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NoneChannelMonitorUpdateErrZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_NoneChannelMonitorUpdateErrZ_is_ok(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR o);
+ export function CResult_NoneChannelMonitorUpdateErrZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneChannelMonitorUpdateErrZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_NoneChannelMonitorUpdateErrZ_free(struct LDKCResult_NoneChannelMonitorUpdateErrZ _res);
export function CResult_NoneChannelMonitorUpdateErrZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NoneChannelMonitorUpdateErrZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR arg);
+ export function CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_clone(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR orig);
export function CResult_NoneChannelMonitorUpdateErrZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.COption_C2Tuple_usizeTransactionZZ_free(_res);
// debug statements here
}
+ // uint64_t COption_C2Tuple_usizeTransactionZZ_clone_ptr(LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR arg);
+ export function COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_clone(const struct LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR orig);
export function COption_C2Tuple_usizeTransactionZZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.COption_C2Tuple_usizeTransactionZZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
- export function COption_NetworkUpdateZ_some(o: number): number {
+ // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
+ export function COption_ClosureReasonZ_some(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.COption_NetworkUpdateZ_some(o);
+ const nativeResponseValue = wasm.COption_ClosureReasonZ_some(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
+ export function COption_ClosureReasonZ_none(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_ClosureReasonZ_none();
+ return nativeResponseValue;
+ }
+ // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
+ export function COption_ClosureReasonZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_ClosureReasonZ_free(_res);
+ // debug statements here
+ }
+ // uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
+ export function COption_ClosureReasonZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_ClosureReasonZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
+ // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
+ export function COption_ClosureReasonZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_ClosureReasonZ_clone(orig);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
+ export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
+ return nativeResponseValue;
+ }
+ // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
+ // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
+ export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
+ // debug statements here
+ }
+ // uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+ }
+ // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
+ export function COption_NetworkUpdateZ_some(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_NetworkUpdateZ_some(o);
return nativeResponseValue;
}
// struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
const nativeResponseValue = wasm.COption_NetworkUpdateZ_free(_res);
// debug statements here
}
+ // uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
+ export function COption_NetworkUpdateZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_NetworkUpdateZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
export function COption_NetworkUpdateZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CVec_SpendableOutputDescriptorZ_free(_res);
// debug statements here
}
+ // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
+ export function COption_EventZ_some(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_EventZ_some(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCOption_EventZ COption_EventZ_none(void);
+ export function COption_EventZ_none(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_EventZ_none();
+ return nativeResponseValue;
+ }
+ // void COption_EventZ_free(struct LDKCOption_EventZ _res);
+ export function COption_EventZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_EventZ_free(_res);
+ // debug statements here
+ }
+ // uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
+ export function COption_EventZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_EventZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
+ // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
+ export function COption_EventZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_EventZ_clone(orig);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
+ export function CResult_COption_EventZDecodeErrorZ_ok(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_EventZDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_COption_EventZDecodeErrorZ_err(e: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_EventZDecodeErrorZ_err(e);
+ return nativeResponseValue;
+ }
+ // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_COption_EventZDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_EventZDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
+ // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
+ export function CResult_COption_EventZDecodeErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_EventZDecodeErrorZ_free(_res);
+ // debug statements here
+ }
+ // uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_COption_EventZDecodeErrorZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_EventZDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+ }
// void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
export function CVec_MessageSendEventZ_free(_res: number[]): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_InitFeaturesDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_InitFeaturesDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
export function CResult_InitFeaturesDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NodeFeaturesDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
export function CResult_NodeFeaturesDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ChannelFeaturesDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_InvoiceFeaturesDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
export function CResult_InvoiceFeaturesDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ScoringParametersDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_ScoringParametersDecodeErrorZ_is_ok(const struct LDKCResult_ScoringParametersDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_ScoringParametersDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ScoringParametersDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_ScoringParametersDecodeErrorZ_free(struct LDKCResult_ScoringParametersDecodeErrorZ _res);
export function CResult_ScoringParametersDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ScorerDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_ScorerDecodeErrorZ_is_ok(const struct LDKCResult_ScorerDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_ScorerDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ScorerDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_ScorerDecodeErrorZ_free(struct LDKCResult_ScorerDecodeErrorZ _res);
export function CResult_ScorerDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NoneNoneZ_err();
return nativeResponseValue;
}
+ // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
+ export function CResult_NoneNoneZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneNoneZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
export function CResult_NoneNoneZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NoneNoneZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
+ export function CResult_NoneNoneZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
export function CResult_NoneNoneZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NoneNoneZ_clone(orig);
return nativeResponseValue;
}
+ // uint64_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg);
+ export function C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
export function C2Tuple_SignatureCVec_SignatureZZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
return nativeResponseValue;
}
+ // bool CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR o);
+ export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg);
+ export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_SignatureNoneZ_err();
return nativeResponseValue;
}
+ // bool CResult_SignatureNoneZ_is_ok(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR o);
+ export function CResult_SignatureNoneZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_SignatureNoneZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
export function CResult_SignatureNoneZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_SignatureNoneZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg);
+ export function CResult_SignatureNoneZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_SignatureNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
export function CResult_SignatureNoneZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_SignDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_SignDecodeErrorZ_is_ok(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_SignDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_SignDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
export function CResult_SignDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_SignDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_SignDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_SignDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
export function CResult_SignDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_RecoverableSignatureNoneZ_err();
return nativeResponseValue;
}
+ // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
+ export function CResult_RecoverableSignatureNoneZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_RecoverableSignatureNoneZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
export function CResult_RecoverableSignatureNoneZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_RecoverableSignatureNoneZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
+ export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
export function CResult_RecoverableSignatureNoneZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_CVec_CVec_u8ZZNoneZ_err();
return nativeResponseValue;
}
+ // bool CResult_CVec_CVec_u8ZZNoneZ_is_ok(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR o);
+ export function CResult_CVec_CVec_u8ZZNoneZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CVec_CVec_u8ZZNoneZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_CVec_CVec_u8ZZNoneZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg);
+ export function CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_InMemorySignerDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_InMemorySignerDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
export function CResult_InMemorySignerDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_InMemorySignerDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
export function CResult_InMemorySignerDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_TransactionNoneZ_err();
return nativeResponseValue;
}
- // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
- export function CResult_TransactionNoneZ_free(_res: number): void {
+ // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
+ export function CResult_TransactionNoneZ_is_ok(o: number): boolean {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_TransactionNoneZ_free(_res);
+ const nativeResponseValue = wasm.CResult_TransactionNoneZ_is_ok(o);
+ return nativeResponseValue;
+ }
+ // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
+ export function CResult_TransactionNoneZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_TransactionNoneZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
+ export function CResult_TransactionNoneZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_TransactionNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
export function CResult_TransactionNoneZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_TransactionNoneZ_clone(orig);
return nativeResponseValue;
}
+ // uint64_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg);
+ export function C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_clone(const struct LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR orig);
export function C2Tuple_BlockHashChannelMonitorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_is_ok(const struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ *NONNULL_PTR o);
+ export function CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ _res);
export function CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone_ptr(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ *NONNULL_PTR arg);
+ export function CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone(const struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ *NONNULL_PTR orig);
export function CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.COption_u16Z_free(_res);
// debug statements here
}
+ // uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
+ export function COption_u16Z_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_u16Z_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
export function COption_u16Z_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NoneAPIErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
+ export function CResult_NoneAPIErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneAPIErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
export function CResult_NoneAPIErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NoneAPIErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
+ export function CResult_NoneAPIErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneAPIErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
export function CResult_NoneAPIErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult__u832APIErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult__u832APIErrorZ_is_ok(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR o);
+ export function CResult__u832APIErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult__u832APIErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult__u832APIErrorZ_free(struct LDKCResult__u832APIErrorZ _res);
export function CResult__u832APIErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult__u832APIErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg);
+ export function CResult__u832APIErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult__u832APIErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_clone(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR orig);
export function CResult__u832APIErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_PaymentIdPaymentSendFailureZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_PaymentIdPaymentSendFailureZ_is_ok(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR o);
+ export function CResult_PaymentIdPaymentSendFailureZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PaymentIdPaymentSendFailureZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_PaymentIdPaymentSendFailureZ_free(struct LDKCResult_PaymentIdPaymentSendFailureZ _res);
export function CResult_PaymentIdPaymentSendFailureZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_PaymentIdPaymentSendFailureZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_PaymentIdPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR arg);
+ export function CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_clone(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR orig);
export function CResult_PaymentIdPaymentSendFailureZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NonePaymentSendFailureZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
+ export function CResult_NonePaymentSendFailureZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NonePaymentSendFailureZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
export function CResult_NonePaymentSendFailureZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NonePaymentSendFailureZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
+ export function CResult_NonePaymentSendFailureZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NonePaymentSendFailureZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
export function CResult_NonePaymentSendFailureZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NonePaymentSendFailureZ_clone(orig);
return nativeResponseValue;
}
+ // uint64_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg);
+ export function C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_clone(const struct LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR orig);
export function C2Tuple_PaymentHashPaymentIdZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR o);
+ export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res);
export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg);
+ export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR orig);
export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CVec_NetAddressZ_free(_res);
// debug statements here
}
+ // uint64_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg);
+ export function C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_clone(const struct LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR orig);
export function C2Tuple_PaymentHashPaymentSecretZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_PaymentSecretAPIErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_PaymentSecretAPIErrorZ_is_ok(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR o);
+ export function CResult_PaymentSecretAPIErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PaymentSecretAPIErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_PaymentSecretAPIErrorZ_free(struct LDKCResult_PaymentSecretAPIErrorZ _res);
export function CResult_PaymentSecretAPIErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_PaymentSecretAPIErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg);
+ export function CResult_PaymentSecretAPIErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PaymentSecretAPIErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_clone(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR orig);
export function CResult_PaymentSecretAPIErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ChannelConfigDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_ChannelConfigDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelConfigDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
export function CResult_ChannelConfigDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ChannelConfigDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
export function CResult_ChannelConfigDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_OutPointDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_OutPointDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_OutPointDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
export function CResult_OutPointDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_OutPointDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_OutPointDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_OutPointDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
export function CResult_OutPointDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.COption_TypeZ_free(_res);
// debug statements here
}
+ // uint64_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
+ export function COption_TypeZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_TypeZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
export function COption_TypeZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_COption_TypeZDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_COption_TypeZDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_TypeZDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
export function CResult_COption_TypeZDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_COption_TypeZDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
export function CResult_COption_TypeZDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_PaymentIdPaymentErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_PaymentIdPaymentErrorZ_is_ok(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR o);
+ export function CResult_PaymentIdPaymentErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PaymentIdPaymentErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_PaymentIdPaymentErrorZ_free(struct LDKCResult_PaymentIdPaymentErrorZ _res);
export function CResult_PaymentIdPaymentErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_PaymentIdPaymentErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg);
+ export function CResult_PaymentIdPaymentErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PaymentIdPaymentErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_clone(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR orig);
export function CResult_PaymentIdPaymentErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_SiPrefixNoneZ_err();
return nativeResponseValue;
}
+ // bool CResult_SiPrefixNoneZ_is_ok(const struct LDKCResult_SiPrefixNoneZ *NONNULL_PTR o);
+ export function CResult_SiPrefixNoneZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_SiPrefixNoneZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_SiPrefixNoneZ_free(struct LDKCResult_SiPrefixNoneZ _res);
export function CResult_SiPrefixNoneZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_SiPrefixNoneZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_SiPrefixNoneZ_clone_ptr(LDKCResult_SiPrefixNoneZ *NONNULL_PTR arg);
+ export function CResult_SiPrefixNoneZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_SiPrefixNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_SiPrefixNoneZ CResult_SiPrefixNoneZ_clone(const struct LDKCResult_SiPrefixNoneZ *NONNULL_PTR orig);
export function CResult_SiPrefixNoneZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_InvoiceNoneZ_err();
return nativeResponseValue;
}
+ // bool CResult_InvoiceNoneZ_is_ok(const struct LDKCResult_InvoiceNoneZ *NONNULL_PTR o);
+ export function CResult_InvoiceNoneZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_InvoiceNoneZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_InvoiceNoneZ_free(struct LDKCResult_InvoiceNoneZ _res);
export function CResult_InvoiceNoneZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_InvoiceNoneZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_InvoiceNoneZ_clone_ptr(LDKCResult_InvoiceNoneZ *NONNULL_PTR arg);
+ export function CResult_InvoiceNoneZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_InvoiceNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_InvoiceNoneZ CResult_InvoiceNoneZ_clone(const struct LDKCResult_InvoiceNoneZ *NONNULL_PTR orig);
export function CResult_InvoiceNoneZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_SignedRawInvoiceNoneZ_err();
return nativeResponseValue;
}
+ // bool CResult_SignedRawInvoiceNoneZ_is_ok(const struct LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR o);
+ export function CResult_SignedRawInvoiceNoneZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_SignedRawInvoiceNoneZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_SignedRawInvoiceNoneZ_free(struct LDKCResult_SignedRawInvoiceNoneZ _res);
export function CResult_SignedRawInvoiceNoneZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_SignedRawInvoiceNoneZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_SignedRawInvoiceNoneZ_clone_ptr(LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR arg);
+ export function CResult_SignedRawInvoiceNoneZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_SignedRawInvoiceNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_SignedRawInvoiceNoneZ CResult_SignedRawInvoiceNoneZ_clone(const struct LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR orig);
export function CResult_SignedRawInvoiceNoneZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_SignedRawInvoiceNoneZ_clone(orig);
return nativeResponseValue;
}
+ // uint64_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg);
+ export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR orig);
export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_PayeePubKeyErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_PayeePubKeyErrorZ_is_ok(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR o);
+ export function CResult_PayeePubKeyErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PayeePubKeyErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_PayeePubKeyErrorZ_free(struct LDKCResult_PayeePubKeyErrorZ _res);
export function CResult_PayeePubKeyErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_PayeePubKeyErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg);
+ export function CResult_PayeePubKeyErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PayeePubKeyErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_clone(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR orig);
export function CResult_PayeePubKeyErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_PositiveTimestampCreationErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
+ export function CResult_PositiveTimestampCreationErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PositiveTimestampCreationErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
export function CResult_PositiveTimestampCreationErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_PositiveTimestampCreationErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
+ export function CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
export function CResult_PositiveTimestampCreationErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NoneSemanticErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_NoneSemanticErrorZ_is_ok(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR o);
+ export function CResult_NoneSemanticErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneSemanticErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_NoneSemanticErrorZ_free(struct LDKCResult_NoneSemanticErrorZ _res);
export function CResult_NoneSemanticErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NoneSemanticErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg);
+ export function CResult_NoneSemanticErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneSemanticErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_clone(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR orig);
export function CResult_NoneSemanticErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_InvoiceSemanticErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_InvoiceSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR o);
+ export function CResult_InvoiceSemanticErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_InvoiceSemanticErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_InvoiceSemanticErrorZ_free(struct LDKCResult_InvoiceSemanticErrorZ _res);
export function CResult_InvoiceSemanticErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_InvoiceSemanticErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg);
+ export function CResult_InvoiceSemanticErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_InvoiceSemanticErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_clone(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR orig);
export function CResult_InvoiceSemanticErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_DescriptionCreationErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
+ export function CResult_DescriptionCreationErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_DescriptionCreationErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
export function CResult_DescriptionCreationErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_DescriptionCreationErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
+ export function CResult_DescriptionCreationErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_DescriptionCreationErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
export function CResult_DescriptionCreationErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ExpiryTimeCreationErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_ExpiryTimeCreationErrorZ_free(struct LDKCResult_ExpiryTimeCreationErrorZ _res);
- export function CResult_ExpiryTimeCreationErrorZ_free(_res: number): void {
+ // bool CResult_ExpiryTimeCreationErrorZ_is_ok(const struct LDKCResult_ExpiryTimeCreationErrorZ *NONNULL_PTR o);
+ export function CResult_ExpiryTimeCreationErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ExpiryTimeCreationErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
+ // void CResult_ExpiryTimeCreationErrorZ_free(struct LDKCResult_ExpiryTimeCreationErrorZ _res);
+ export function CResult_ExpiryTimeCreationErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ExpiryTimeCreationErrorZ_free(_res);
+ // debug statements here
+ }
+ // uint64_t CResult_ExpiryTimeCreationErrorZ_clone_ptr(LDKCResult_ExpiryTimeCreationErrorZ *NONNULL_PTR arg);
+ export function CResult_ExpiryTimeCreationErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ExpiryTimeCreationErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_ExpiryTimeCreationErrorZ CResult_ExpiryTimeCreationErrorZ_clone(const struct LDKCResult_ExpiryTimeCreationErrorZ *NONNULL_PTR orig);
+ export function CResult_ExpiryTimeCreationErrorZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ExpiryTimeCreationErrorZ_clone(orig);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
+ export function CResult_PrivateRouteCreationErrorZ_ok(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PrivateRouteCreationErrorZ_ok(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
+ export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PrivateRouteCreationErrorZ_err(e);
+ return nativeResponseValue;
+ }
+ // bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
+ export function CResult_PrivateRouteCreationErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PrivateRouteCreationErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
+ // void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
+ export function CResult_PrivateRouteCreationErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PrivateRouteCreationErrorZ_free(_res);
+ // debug statements here
+ }
+ // uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
+ export function CResult_PrivateRouteCreationErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PrivateRouteCreationErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
+ export function CResult_PrivateRouteCreationErrorZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PrivateRouteCreationErrorZ_clone(orig);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_StringErrorZ CResult_StringErrorZ_ok(struct LDKStr o);
+ export function CResult_StringErrorZ_ok(o: String): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_StringErrorZ_ok(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_StringErrorZ CResult_StringErrorZ_err(enum LDKSecp256k1Error e);
+ export function CResult_StringErrorZ_err(e: Secp256k1Error): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_StringErrorZ_err(e);
+ return nativeResponseValue;
+ }
+ // bool CResult_StringErrorZ_is_ok(const struct LDKCResult_StringErrorZ *NONNULL_PTR o);
+ export function CResult_StringErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_StringErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
+ // void CResult_StringErrorZ_free(struct LDKCResult_StringErrorZ _res);
+ export function CResult_StringErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_StringErrorZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
+ export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
+ return nativeResponseValue;
+ }
+ // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
+ // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
+ export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
+ // debug statements here
+ }
+ // uint64_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ExpiryTimeCreationErrorZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
}
- // struct LDKCResult_ExpiryTimeCreationErrorZ CResult_ExpiryTimeCreationErrorZ_clone(const struct LDKCResult_ExpiryTimeCreationErrorZ *NONNULL_PTR orig);
- export function CResult_ExpiryTimeCreationErrorZ_clone(orig: number): number {
+ // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ExpiryTimeCreationErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
- export function CResult_PrivateRouteCreationErrorZ_ok(o: number): number {
+ // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
+ export function COption_MonitorEventZ_some(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_PrivateRouteCreationErrorZ_ok(o);
+ const nativeResponseValue = wasm.COption_MonitorEventZ_some(o);
return nativeResponseValue;
}
- // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
- export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): number {
+ // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
+ export function COption_MonitorEventZ_none(): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_PrivateRouteCreationErrorZ_err(e);
+ const nativeResponseValue = wasm.COption_MonitorEventZ_none();
return nativeResponseValue;
}
- // void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
- export function CResult_PrivateRouteCreationErrorZ_free(_res: number): void {
+ // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
+ export function COption_MonitorEventZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_PrivateRouteCreationErrorZ_free(_res);
+ const nativeResponseValue = wasm.COption_MonitorEventZ_free(_res);
// debug statements here
}
- // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
- export function CResult_PrivateRouteCreationErrorZ_clone(orig: number): number {
+ // uint64_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
+ export function COption_MonitorEventZ_clone_ptr(arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_PrivateRouteCreationErrorZ_clone(orig);
+ const nativeResponseValue = wasm.COption_MonitorEventZ_clone_ptr(arg);
return nativeResponseValue;
}
- // struct LDKCResult_StringErrorZ CResult_StringErrorZ_ok(struct LDKStr o);
- export function CResult_StringErrorZ_ok(o: String): number {
+ // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
+ export function COption_MonitorEventZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_StringErrorZ_ok(o);
+ const nativeResponseValue = wasm.COption_MonitorEventZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_StringErrorZ CResult_StringErrorZ_err(enum LDKSecp256k1Error e);
- export function CResult_StringErrorZ_err(e: Secp256k1Error): number {
+ // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
+ export function CResult_COption_MonitorEventZDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_StringErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_COption_MonitorEventZDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // void CResult_StringErrorZ_free(struct LDKCResult_StringErrorZ _res);
- export function CResult_StringErrorZ_free(_res: number): void {
+ // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_COption_MonitorEventZDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_StringErrorZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_COption_MonitorEventZDecodeErrorZ_err(e);
+ return nativeResponseValue;
}
- // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
- export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: number): number {
+ // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o: number): boolean {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: number): number {
+ // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
+ export function CResult_COption_MonitorEventZDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CResult_COption_MonitorEventZDecodeErrorZ_free(_res);
+ // debug statements here
}
- // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
- export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: number): void {
+ // uint64_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
}
- // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_COption_MonitorEventZDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_COption_MonitorEventZDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
// struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
const nativeResponseValue = wasm.CResult_HTLCUpdateDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_HTLCUpdateDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_HTLCUpdateDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
export function CResult_HTLCUpdateDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_HTLCUpdateDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NoneMonitorUpdateErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_NoneMonitorUpdateErrorZ_is_ok(const struct LDKCResult_NoneMonitorUpdateErrorZ *NONNULL_PTR o);
+ export function CResult_NoneMonitorUpdateErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneMonitorUpdateErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_NoneMonitorUpdateErrorZ_free(struct LDKCResult_NoneMonitorUpdateErrorZ _res);
export function CResult_NoneMonitorUpdateErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NoneMonitorUpdateErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_NoneMonitorUpdateErrorZ_clone_ptr(LDKCResult_NoneMonitorUpdateErrorZ *NONNULL_PTR arg);
+ export function CResult_NoneMonitorUpdateErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneMonitorUpdateErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_clone(const struct LDKCResult_NoneMonitorUpdateErrorZ *NONNULL_PTR orig);
export function CResult_NoneMonitorUpdateErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NoneMonitorUpdateErrorZ_clone(orig);
return nativeResponseValue;
}
+ // uint64_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg);
+ export function C2Tuple_OutPointScriptZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_OutPointScriptZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_clone(const struct LDKC2Tuple_OutPointScriptZ *NONNULL_PTR orig);
export function C2Tuple_OutPointScriptZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.C2Tuple_OutPointScriptZ_free(_res);
// debug statements here
}
+ // uint64_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg);
+ export function C2Tuple_u32ScriptZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_u32ScriptZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_clone(const struct LDKC2Tuple_u32ScriptZ *NONNULL_PTR orig);
export function C2Tuple_u32ScriptZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CVec_C2Tuple_u32ScriptZZ_free(_res);
// debug statements here
}
+ // uint64_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg);
+ export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR orig);
export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CVec_TransactionZ_free(_res);
// debug statements here
}
+ // uint64_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
+ export function C2Tuple_u32TxOutZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_u32TxOutZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
export function C2Tuple_u32TxOutZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CVec_C2Tuple_u32TxOutZZ_free(_res);
// debug statements here
}
+ // uint64_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
+ export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
+ export function CResult_NoneLightningErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
export function CResult_NoneLightningErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
+ export function CResult_NoneLightningErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
export function CResult_NoneLightningErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_clone(orig);
return nativeResponseValue;
}
+ // uint64_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
+ export function C2Tuple_PublicKeyTypeZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_PublicKeyTypeZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
export function C2Tuple_PublicKeyTypeZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_boolLightningErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
+ export function CResult_boolLightningErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_boolLightningErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
export function CResult_boolLightningErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_boolLightningErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
+ export function CResult_boolLightningErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_boolLightningErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
export function CResult_boolLightningErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_boolLightningErrorZ_clone(orig);
return nativeResponseValue;
}
+ // uint64_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
+ export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_CVec_u8ZPeerHandleErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
+ export function CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
+ export function CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NonePeerHandleErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
+ export function CResult_NonePeerHandleErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NonePeerHandleErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
export function CResult_NonePeerHandleErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NonePeerHandleErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
+ export function CResult_NonePeerHandleErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NonePeerHandleErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
export function CResult_NonePeerHandleErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_boolPeerHandleErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
+ export function CResult_boolPeerHandleErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_boolPeerHandleErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
export function CResult_boolPeerHandleErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_boolPeerHandleErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
+ export function CResult_boolPeerHandleErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_boolPeerHandleErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
export function CResult_boolPeerHandleErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NodeIdDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_NodeIdDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NodeIdDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
export function CResult_NodeIdDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NodeIdDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_NodeIdDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NodeIdDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
export function CResult_NodeIdDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NodeIdDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
+ // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
+ export function CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_COption_NetworkUpdateZDecodeErrorZ_err(e: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_NetworkUpdateZDecodeErrorZ_err(e);
+ return nativeResponseValue;
+ }
+ // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
+ // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
+ export function CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res);
+ // debug statements here
+ }
+ // uint64_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+ }
// struct LDKCOption_AccessZ COption_AccessZ_some(struct LDKAccess o);
export function COption_AccessZ_some(o: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_DirectionalChannelInfoDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_DirectionalChannelInfoDecodeErrorZ_free(struct LDKCResult_DirectionalChannelInfoDecodeErrorZ _res);
export function CResult_DirectionalChannelInfoDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_DirectionalChannelInfoDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_clone(const struct LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR orig);
export function CResult_DirectionalChannelInfoDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ChannelInfoDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_ChannelInfoDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelInfoDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
export function CResult_ChannelInfoDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ChannelInfoDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
export function CResult_ChannelInfoDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_RoutingFeesDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_RoutingFeesDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_RoutingFeesDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
export function CResult_RoutingFeesDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_RoutingFeesDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
export function CResult_RoutingFeesDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NodeInfoDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_NodeInfoDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NodeInfoDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
export function CResult_NodeInfoDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NodeInfoDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_NodeInfoDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NodeInfoDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
export function CResult_NodeInfoDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NetworkGraphDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_NetworkGraphDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NetworkGraphDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
export function CResult_NetworkGraphDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NetworkGraphDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_NetworkGraphDecodeErrorZ_clone_ptr(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_NetworkGraphDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NetworkGraphDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_clone(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR orig);
export function CResult_NetworkGraphDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.COption_CVec_NetAddressZZ_free(_res);
// debug statements here
}
+ // uint64_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg);
+ export function COption_CVec_NetAddressZZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_CVec_NetAddressZZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_clone(const struct LDKCOption_CVec_NetAddressZZ *NONNULL_PTR orig);
export function COption_CVec_NetAddressZZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NetAddressDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_NetAddressDecodeErrorZ_is_ok(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_NetAddressDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NetAddressDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
export function CResult_NetAddressDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NetAddressDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_NetAddressDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NetAddressDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
export function CResult_NetAddressDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_AcceptChannelDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_AcceptChannelDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
export function CResult_AcceptChannelDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_AcceptChannelDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
export function CResult_AcceptChannelDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ChannelReestablishDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
export function CResult_ChannelReestablishDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ChannelReestablishDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ClosingSignedDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ClosingSignedDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
export function CResult_ClosingSignedDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ClosingSignedDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
export function CResult_ClosingSignedDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_CommitmentSignedDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
export function CResult_CommitmentSignedDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_CommitmentSignedDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_FundingCreatedDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_FundingCreatedDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_FundingCreatedDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
export function CResult_FundingCreatedDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_FundingCreatedDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
export function CResult_FundingCreatedDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_FundingSignedDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_FundingSignedDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_FundingSignedDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
export function CResult_FundingSignedDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_FundingSignedDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_FundingSignedDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_FundingSignedDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
export function CResult_FundingSignedDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_FundingLockedDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_FundingLockedDecodeErrorZ_is_ok(const struct LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_FundingLockedDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_FundingLockedDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_FundingLockedDecodeErrorZ_free(struct LDKCResult_FundingLockedDecodeErrorZ _res);
export function CResult_FundingLockedDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_FundingLockedDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_FundingLockedDecodeErrorZ_clone_ptr(LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_FundingLockedDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_FundingLockedDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_clone(const struct LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR orig);
export function CResult_FundingLockedDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_InitDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_InitDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_InitDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
export function CResult_InitDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_InitDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_InitDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_InitDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
export function CResult_InitDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_OpenChannelDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_OpenChannelDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_OpenChannelDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
export function CResult_OpenChannelDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_OpenChannelDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_OpenChannelDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_OpenChannelDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
export function CResult_OpenChannelDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_RevokeAndACKDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_RevokeAndACKDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_RevokeAndACKDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
export function CResult_RevokeAndACKDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_RevokeAndACKDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ShutdownDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_ShutdownDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ShutdownDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
export function CResult_ShutdownDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ShutdownDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_ShutdownDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ShutdownDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
export function CResult_ShutdownDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_UpdateFailHTLCDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_UpdateFeeDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_UpdateFeeDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_UpdateFeeDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
export function CResult_UpdateFeeDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_UpdateFeeDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
export function CResult_UpdateFeeDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_UpdateAddHTLCDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_PingDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_PingDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PingDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
export function CResult_PingDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_PingDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_PingDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PingDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
export function CResult_PingDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_PongDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_PongDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PongDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
export function CResult_PongDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_PongDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_PongDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PongDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
export function CResult_PongDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ChannelAnnouncementDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
+ // debug statements here
+ }
+ // uint64_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
}
// struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: number): number {
const nativeResponseValue = wasm.CResult_ChannelUpdateDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_ChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelUpdateDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
export function CResult_ChannelUpdateDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ChannelUpdateDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ErrorMessageDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_ErrorMessageDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ErrorMessageDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
export function CResult_ErrorMessageDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ErrorMessageDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
export function CResult_ErrorMessageDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NodeAnnouncementDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_NodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NodeAnnouncementDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NodeAnnouncementDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_QueryChannelRangeDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_QueryChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_QueryChannelRangeDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_QueryChannelRangeDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ReplyChannelRangeDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_GossipTimestampFilterDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
+ export function CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
+ export function CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_InvoiceSignOrCreationErrorZ_err(e);
return nativeResponseValue;
}
+ // bool CResult_InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
+ export function CResult_InvoiceSignOrCreationErrorZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_InvoiceSignOrCreationErrorZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_InvoiceSignOrCreationErrorZ_free(struct LDKCResult_InvoiceSignOrCreationErrorZ _res);
export function CResult_InvoiceSignOrCreationErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_InvoiceSignOrCreationErrorZ_free(_res);
// debug statements here
}
+ // uint64_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
+ export function CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
export function CResult_InvoiceSignOrCreationErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_LockedChannelMonitorNoneZ_err();
return nativeResponseValue;
}
+ // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
+ export function CResult_LockedChannelMonitorNoneZ_is_ok(o: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_LockedChannelMonitorNoneZ_is_ok(o);
+ return nativeResponseValue;
+ }
// void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
export function CResult_LockedChannelMonitorNoneZ_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.PaymentPurpose_free(this_ptr);
// debug statements here
}
+ // uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
+ export function PaymentPurpose_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.PaymentPurpose_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
export function PaymentPurpose_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ClosureReason_free(this_ptr);
// debug statements here
}
+ // uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
+ export function ClosureReason_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosureReason_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
export function ClosureReason_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ClosureReason_write(obj);
return decodeArray(nativeResponseValue);
}
+ // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
+ export function ClosureReason_read(ser: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosureReason_read(encodeArray(ser));
+ return nativeResponseValue;
+ }
// void Event_free(struct LDKEvent this_ptr);
export function Event_free(this_ptr: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.Event_free(this_ptr);
// debug statements here
}
+ // uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
+ export function Event_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Event_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
export function Event_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.Event_write(obj);
return decodeArray(nativeResponseValue);
}
+ // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
+ export function Event_read(ser: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Event_read(encodeArray(ser));
+ return nativeResponseValue;
+ }
// void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
export function MessageSendEvent_free(this_ptr: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.MessageSendEvent_free(this_ptr);
// debug statements here
}
+ // uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
+ export function MessageSendEvent_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.MessageSendEvent_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
export function MessageSendEvent_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.APIError_free(this_ptr);
// debug statements here
}
+ // uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
+ export function APIError_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.APIError_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
export function APIError_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.Level_max();
return nativeResponseValue;
}
+ // void Record_free(struct LDKRecord this_obj);
+ export function Record_free(this_obj: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Record_free(this_obj);
+ // debug statements here
+ }
+ // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
+ export function Record_get_level(this_ptr: number): Level {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Record_get_level(this_ptr);
+ return nativeResponseValue;
+ }
+ // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
+ export function Record_set_level(this_ptr: number, val: Level): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Record_set_level(this_ptr, val);
+ // debug statements here
+ }
+ // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
+ export function Record_get_args(this_ptr: number): String {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Record_get_args(this_ptr);
+ return nativeResponseValue;
+ }
+ // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
+ export function Record_set_args(this_ptr: number, val: String): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Record_set_args(this_ptr, val);
+ // debug statements here
+ }
+ // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
+ export function Record_get_module_path(this_ptr: number): String {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Record_get_module_path(this_ptr);
+ return nativeResponseValue;
+ }
+ // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
+ export function Record_set_module_path(this_ptr: number, val: String): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Record_set_module_path(this_ptr, val);
+ // debug statements here
+ }
+ // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
+ export function Record_get_file(this_ptr: number): String {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Record_get_file(this_ptr);
+ return nativeResponseValue;
+ }
+ // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
+ export function Record_set_file(this_ptr: number, val: String): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Record_set_file(this_ptr, val);
+ // debug statements here
+ }
+ // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
+ export function Record_get_line(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Record_get_line(this_ptr);
+ return nativeResponseValue;
+ }
+ // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
+ export function Record_set_line(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Record_set_line(this_ptr, val);
+ // debug statements here
+ }
+ // uint64_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
+ export function Record_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Record_clone_ptr(arg);
+ return nativeResponseValue;
+ }
+ // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
+ export function Record_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Record_clone(orig);
+ return nativeResponseValue;
+ }
// void Logger_free(struct LDKLogger this_ptr);
export function Logger_free(this_ptr: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg, our_htlc_minimum_msat_arg);
return nativeResponseValue;
}
+ // uint64_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
+ export function ChannelHandshakeConfig_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeConfig_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
export function ChannelHandshakeConfig_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelHandshakeLimits_new(min_funding_satoshis_arg, max_htlc_minimum_msat_arg, min_max_htlc_value_in_flight_msat_arg, max_channel_reserve_satoshis_arg, min_max_accepted_htlcs_arg, max_minimum_depth_arg, force_announced_channel_preference_arg, their_to_self_delay_arg);
return nativeResponseValue;
}
+ // uint64_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
+ export function ChannelHandshakeLimits_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeLimits_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
export function ChannelHandshakeLimits_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelConfig_new(forwarding_fee_proportional_millionths_arg, forwarding_fee_base_msat_arg, cltv_expiry_delta_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg, max_dust_htlc_exposure_msat_arg, force_close_avoidance_max_fee_satoshis_arg);
return nativeResponseValue;
}
+ // uint64_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
+ export function ChannelConfig_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelConfig_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
export function ChannelConfig_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.UserConfig_new(own_channel_config_arg, peer_channel_config_limits_arg, channel_options_arg, accept_forwards_to_priv_channels_arg);
return nativeResponseValue;
}
+ // uint64_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
+ export function UserConfig_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.UserConfig_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
export function UserConfig_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.BestBlock_free(this_obj);
// debug statements here
}
+ // uint64_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
+ export function BestBlock_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BestBlock_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
export function BestBlock_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.WatchedOutput_new(encodeArray(block_hash_arg), outpoint_arg, encodeArray(script_pubkey_arg));
return nativeResponseValue;
}
+ // uint64_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
+ export function WatchedOutput_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.WatchedOutput_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
export function WatchedOutput_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.MonitorUpdateId_free(this_obj);
// debug statements here
}
+ // uint64_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
+ export function MonitorUpdateId_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.MonitorUpdateId_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
export function MonitorUpdateId_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelMonitorUpdate_set_update_id(this_ptr, val);
// debug statements here
}
+ // uint64_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
+ export function ChannelMonitorUpdate_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitorUpdate_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
export function ChannelMonitorUpdate_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.MonitorUpdateError_new(a_arg);
return nativeResponseValue;
}
+ // uint64_t MonitorUpdateError_clone_ptr(LDKMonitorUpdateError *NONNULL_PTR arg);
+ export function MonitorUpdateError_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.MonitorUpdateError_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKMonitorUpdateError MonitorUpdateError_clone(const struct LDKMonitorUpdateError *NONNULL_PTR orig);
export function MonitorUpdateError_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.MonitorEvent_free(this_ptr);
// debug statements here
}
+ // uint64_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
+ export function MonitorEvent_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.MonitorEvent_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
export function MonitorEvent_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.MonitorEvent_write(obj);
return decodeArray(nativeResponseValue);
}
+ // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
+ export function MonitorEvent_read(ser: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.MonitorEvent_read(encodeArray(ser));
+ return nativeResponseValue;
+ }
// void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
export function HTLCUpdate_free(this_obj: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.HTLCUpdate_free(this_obj);
// debug statements here
}
+ // uint64_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
+ export function HTLCUpdate_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.HTLCUpdate_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
export function HTLCUpdate_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.Balance_free(this_ptr);
// debug statements here
}
+ // uint64_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
+ export function Balance_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Balance_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
export function Balance_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelMonitor_free(this_obj);
// debug statements here
}
+ // uint64_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
+ export function ChannelMonitor_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitor_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
export function ChannelMonitor_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.OutPoint_new(encodeArray(txid_arg), index_arg);
return nativeResponseValue;
}
+ // uint64_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
+ export function OutPoint_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.OutPoint_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
export function OutPoint_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_new(outpoint_arg, encodeArray(per_commitment_point_arg), to_self_delay_arg, output_arg, encodeArray(revocation_pubkey_arg), encodeArray(channel_keys_id_arg), channel_value_satoshis_arg);
return nativeResponseValue;
}
+ // uint64_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
+ export function DelayedPaymentOutputDescriptor_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
export function DelayedPaymentOutputDescriptor_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, encodeArray(channel_keys_id_arg), channel_value_satoshis_arg);
return nativeResponseValue;
}
+ // uint64_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
+ export function StaticPaymentOutputDescriptor_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
export function StaticPaymentOutputDescriptor_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.SpendableOutputDescriptor_free(this_ptr);
// debug statements here
}
+ // uint64_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
+ export function SpendableOutputDescriptor_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SpendableOutputDescriptor_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
export function SpendableOutputDescriptor_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.BaseSign_free(this_ptr);
// debug statements here
}
+ // uint64_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg);
+ export function Sign_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Sign_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKSign Sign_clone(const struct LDKSign *NONNULL_PTR orig);
export function Sign_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.InMemorySigner_set_commitment_seed(this_ptr, encodeArray(val));
// debug statements here
}
+ // uint64_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
+ export function InMemorySigner_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InMemorySigner_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
export function InMemorySigner_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChainParameters_new(network_arg, best_block_arg);
return nativeResponseValue;
}
+ // uint64_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
+ export function ChainParameters_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChainParameters_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
export function ChainParameters_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
return nativeResponseValue;
}
+ // uint64_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
+ export function CounterpartyForwardingInfo_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CounterpartyForwardingInfo_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
export function CounterpartyForwardingInfo_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelCounterparty_new(encodeArray(node_id_arg), features_arg, unspendable_punishment_reserve_arg, forwarding_info_arg);
return nativeResponseValue;
}
+ // uint64_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
+ export function ChannelCounterparty_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelCounterparty_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
export function ChannelCounterparty_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelDetails_new(encodeArray(channel_id_arg), counterparty_arg, funding_txo_arg, short_channel_id_arg, channel_value_satoshis_arg, unspendable_punishment_reserve_arg, user_channel_id_arg, outbound_capacity_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg, force_close_spend_delay_arg, is_outbound_arg, is_funding_locked_arg, is_usable_arg, is_public_arg);
return nativeResponseValue;
}
+ // uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
+ export function ChannelDetails_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelDetails_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
export function ChannelDetails_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.PaymentSendFailure_free(this_ptr);
// debug statements here
}
+ // uint64_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
+ export function PaymentSendFailure_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.PaymentSendFailure_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
export function PaymentSendFailure_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.DecodeError_free(this_obj);
// debug statements here
}
+ // uint64_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
+ export function DecodeError_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.DecodeError_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
export function DecodeError_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.Init_new(features_arg);
return nativeResponseValue;
}
+ // uint64_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
+ export function Init_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Init_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
export function Init_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ErrorMessage_new(encodeArray(channel_id_arg), data_arg);
return nativeResponseValue;
}
+ // uint64_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
+ export function ErrorMessage_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ErrorMessage_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
export function ErrorMessage_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.Ping_new(ponglen_arg, byteslen_arg);
return nativeResponseValue;
}
+ // uint64_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
+ export function Ping_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Ping_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
export function Ping_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.Pong_new(byteslen_arg);
return nativeResponseValue;
}
+ // uint64_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
+ export function Pong_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Pong_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
export function Pong_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.OpenChannel_set_channel_flags(this_ptr, val);
// debug statements here
}
+ // uint64_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
+ export function OpenChannel_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.OpenChannel_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
export function OpenChannel_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.AcceptChannel_set_first_per_commitment_point(this_ptr, encodeArray(val));
// debug statements here
}
+ // uint64_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
+ export function AcceptChannel_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.AcceptChannel_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
export function AcceptChannel_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.FundingCreated_new(encodeArray(temporary_channel_id_arg), encodeArray(funding_txid_arg), funding_output_index_arg, encodeArray(signature_arg));
return nativeResponseValue;
}
+ // uint64_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
+ export function FundingCreated_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.FundingCreated_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
export function FundingCreated_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.FundingSigned_new(encodeArray(channel_id_arg), encodeArray(signature_arg));
return nativeResponseValue;
}
+ // uint64_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
+ export function FundingSigned_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.FundingSigned_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
export function FundingSigned_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.FundingLocked_new(encodeArray(channel_id_arg), encodeArray(next_per_commitment_point_arg));
return nativeResponseValue;
}
+ // uint64_t FundingLocked_clone_ptr(LDKFundingLocked *NONNULL_PTR arg);
+ export function FundingLocked_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.FundingLocked_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKFundingLocked FundingLocked_clone(const struct LDKFundingLocked *NONNULL_PTR orig);
export function FundingLocked_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.Shutdown_new(encodeArray(channel_id_arg), encodeArray(scriptpubkey_arg));
return nativeResponseValue;
}
+ // uint64_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
+ export function Shutdown_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Shutdown_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
export function Shutdown_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
return nativeResponseValue;
}
+ // uint64_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
+ export function ClosingSignedFeeRange_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosingSignedFeeRange_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
export function ClosingSignedFeeRange_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ClosingSigned_new(encodeArray(channel_id_arg), fee_satoshis_arg, encodeArray(signature_arg), fee_range_arg);
return nativeResponseValue;
}
+ // uint64_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
+ export function ClosingSigned_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosingSigned_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
export function ClosingSigned_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.UpdateAddHTLC_set_cltv_expiry(this_ptr, val);
// debug statements here
}
+ // uint64_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
+ export function UpdateAddHTLC_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.UpdateAddHTLC_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
export function UpdateAddHTLC_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.UpdateFulfillHTLC_new(encodeArray(channel_id_arg), htlc_id_arg, encodeArray(payment_preimage_arg));
return nativeResponseValue;
}
+ // uint64_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
+ export function UpdateFulfillHTLC_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.UpdateFulfillHTLC_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
export function UpdateFulfillHTLC_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.UpdateFailHTLC_set_htlc_id(this_ptr, val);
// debug statements here
}
+ // uint64_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
+ export function UpdateFailHTLC_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.UpdateFailHTLC_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
export function UpdateFailHTLC_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.UpdateFailMalformedHTLC_set_failure_code(this_ptr, val);
// debug statements here
}
+ // uint64_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
+ export function UpdateFailMalformedHTLC_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.UpdateFailMalformedHTLC_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
export function UpdateFailMalformedHTLC_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CommitmentSigned_new(encodeArray(channel_id_arg), encodeArray(signature_arg), htlc_signatures_arg);
return nativeResponseValue;
}
+ // uint64_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
+ export function CommitmentSigned_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CommitmentSigned_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
export function CommitmentSigned_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.RevokeAndACK_new(encodeArray(channel_id_arg), encodeArray(per_commitment_secret_arg), encodeArray(next_per_commitment_point_arg));
return nativeResponseValue;
}
+ // uint64_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
+ export function RevokeAndACK_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.RevokeAndACK_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
export function RevokeAndACK_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.UpdateFee_new(encodeArray(channel_id_arg), feerate_per_kw_arg);
return nativeResponseValue;
}
+ // uint64_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
+ export function UpdateFee_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.UpdateFee_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
export function UpdateFee_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.DataLossProtect_new(encodeArray(your_last_per_commitment_secret_arg), encodeArray(my_current_per_commitment_point_arg));
return nativeResponseValue;
}
+ // uint64_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg);
+ export function DataLossProtect_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.DataLossProtect_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKDataLossProtect DataLossProtect_clone(const struct LDKDataLossProtect *NONNULL_PTR orig);
export function DataLossProtect_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelReestablish_set_next_remote_commitment_number(this_ptr, val);
// debug statements here
}
+ // uint64_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
+ export function ChannelReestablish_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelReestablish_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
export function ChannelReestablish_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.AnnouncementSignatures_new(encodeArray(channel_id_arg), short_channel_id_arg, encodeArray(node_signature_arg), encodeArray(bitcoin_signature_arg));
return nativeResponseValue;
}
+ // uint64_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
+ export function AnnouncementSignatures_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.AnnouncementSignatures_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
export function AnnouncementSignatures_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.NetAddress_free(this_ptr);
// debug statements here
}
+ // uint64_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg);
+ export function NetAddress_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NetAddress_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKNetAddress NetAddress_clone(const struct LDKNetAddress *NONNULL_PTR orig);
export function NetAddress_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.UnsignedNodeAnnouncement_set_addresses(this_ptr, val);
// debug statements here
}
+ // uint64_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
+ export function UnsignedNodeAnnouncement_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.UnsignedNodeAnnouncement_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
export function UnsignedNodeAnnouncement_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.NodeAnnouncement_new(encodeArray(signature_arg), contents_arg);
return nativeResponseValue;
}
+ // uint64_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
+ export function NodeAnnouncement_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NodeAnnouncement_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
export function NodeAnnouncement_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr, encodeArray(val));
// debug statements here
}
+ // uint64_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
+ export function UnsignedChannelAnnouncement_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.UnsignedChannelAnnouncement_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
export function UnsignedChannelAnnouncement_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelAnnouncement_new(encodeArray(node_signature_1_arg), encodeArray(node_signature_2_arg), encodeArray(bitcoin_signature_1_arg), encodeArray(bitcoin_signature_2_arg), contents_arg);
return nativeResponseValue;
}
+ // uint64_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
+ export function ChannelAnnouncement_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelAnnouncement_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
export function ChannelAnnouncement_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr, val);
// debug statements here
}
+ // uint64_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
+ export function UnsignedChannelUpdate_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.UnsignedChannelUpdate_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
export function UnsignedChannelUpdate_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelUpdate_new(encodeArray(signature_arg), contents_arg);
return nativeResponseValue;
}
+ // uint64_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
+ export function ChannelUpdate_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelUpdate_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
export function ChannelUpdate_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.QueryChannelRange_new(encodeArray(chain_hash_arg), first_blocknum_arg, number_of_blocks_arg);
return nativeResponseValue;
}
+ // uint64_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
+ export function QueryChannelRange_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.QueryChannelRange_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
export function QueryChannelRange_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ReplyChannelRange_new(encodeArray(chain_hash_arg), first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
return nativeResponseValue;
}
+ // uint64_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
+ export function ReplyChannelRange_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ReplyChannelRange_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
export function ReplyChannelRange_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.QueryShortChannelIds_new(encodeArray(chain_hash_arg), short_channel_ids_arg);
return nativeResponseValue;
}
+ // uint64_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
+ export function QueryShortChannelIds_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.QueryShortChannelIds_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
export function QueryShortChannelIds_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ReplyShortChannelIdsEnd_new(encodeArray(chain_hash_arg), full_information_arg);
return nativeResponseValue;
}
+ // uint64_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
+ export function ReplyShortChannelIdsEnd_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ReplyShortChannelIdsEnd_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
export function ReplyShortChannelIdsEnd_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.GossipTimestampFilter_new(encodeArray(chain_hash_arg), first_timestamp_arg, timestamp_range_arg);
return nativeResponseValue;
}
+ // uint64_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
+ export function GossipTimestampFilter_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.GossipTimestampFilter_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
export function GossipTimestampFilter_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ErrorAction_free(this_ptr);
// debug statements here
}
+ // uint64_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
+ export function ErrorAction_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ErrorAction_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
export function ErrorAction_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.LightningError_new(err_arg, action_arg);
return nativeResponseValue;
}
+ // uint64_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
+ export function LightningError_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.LightningError_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
export function LightningError_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CommitmentUpdate_new(update_add_htlcs_arg, update_fulfill_htlcs_arg, update_fail_htlcs_arg, update_fail_malformed_htlcs_arg, update_fee_arg, commitment_signed_arg);
return nativeResponseValue;
}
+ // uint64_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
+ export function CommitmentUpdate_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CommitmentUpdate_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
export function CommitmentUpdate_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.MessageHandler_new(chan_handler_arg, route_handler_arg);
return nativeResponseValue;
}
+ // uint64_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
+ export function SocketDescriptor_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SocketDescriptor_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
export function SocketDescriptor_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.PeerHandleError_new(no_connection_possible_arg);
return nativeResponseValue;
}
+ // uint64_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
+ export function PeerHandleError_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.PeerHandleError_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
export function PeerHandleError_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.TxCreationKeys_new(encodeArray(per_commitment_point_arg), encodeArray(revocation_key_arg), encodeArray(broadcaster_htlc_key_arg), encodeArray(countersignatory_htlc_key_arg), encodeArray(broadcaster_delayed_payment_key_arg));
return nativeResponseValue;
}
+ // uint64_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
+ export function TxCreationKeys_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TxCreationKeys_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
export function TxCreationKeys_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelPublicKeys_new(encodeArray(funding_pubkey_arg), encodeArray(revocation_basepoint_arg), encodeArray(payment_point_arg), encodeArray(delayed_payment_basepoint_arg), encodeArray(htlc_basepoint_arg));
return nativeResponseValue;
}
+ // uint64_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
+ export function ChannelPublicKeys_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelPublicKeys_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
export function ChannelPublicKeys_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, encodeArray(payment_hash_arg), transaction_output_index_arg);
return nativeResponseValue;
}
+ // uint64_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
+ export function HTLCOutputInCommitment_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.HTLCOutputInCommitment_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
export function HTLCOutputInCommitment_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelTransactionParameters_new(holder_pubkeys_arg, holder_selected_contest_delay_arg, is_outbound_from_holder_arg, counterparty_parameters_arg, funding_outpoint_arg);
return nativeResponseValue;
}
+ // uint64_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
+ export function ChannelTransactionParameters_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelTransactionParameters_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
export function ChannelTransactionParameters_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CounterpartyChannelTransactionParameters_new(pubkeys_arg, selected_contest_delay_arg);
return nativeResponseValue;
}
+ // uint64_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
+ export function CounterpartyChannelTransactionParameters_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CounterpartyChannelTransactionParameters_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
export function CounterpartyChannelTransactionParameters_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr, val);
// debug statements here
}
+ // uint64_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
+ export function HolderCommitmentTransaction_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.HolderCommitmentTransaction_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
export function HolderCommitmentTransaction_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.BuiltCommitmentTransaction_new(encodeArray(transaction_arg), encodeArray(txid_arg));
return nativeResponseValue;
}
+ // uint64_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
+ export function BuiltCommitmentTransaction_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BuiltCommitmentTransaction_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
export function BuiltCommitmentTransaction_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ClosingTransaction_free(this_obj);
// debug statements here
}
+ // uint64_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
+ export function ClosingTransaction_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosingTransaction_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
export function ClosingTransaction_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CommitmentTransaction_free(this_obj);
// debug statements here
}
+ // uint64_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
+ export function CommitmentTransaction_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CommitmentTransaction_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
export function CommitmentTransaction_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.InvoiceFeatures_eq(a, b);
return nativeResponseValue;
}
+ // uint64_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
+ export function InitFeatures_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InitFeatures_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
export function InitFeatures_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.InitFeatures_clone(orig);
return nativeResponseValue;
}
+ // uint64_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
+ export function NodeFeatures_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NodeFeatures_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
export function NodeFeatures_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.NodeFeatures_clone(orig);
return nativeResponseValue;
}
+ // uint64_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
+ export function ChannelFeatures_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelFeatures_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
export function ChannelFeatures_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelFeatures_clone(orig);
return nativeResponseValue;
}
+ // uint64_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg);
+ export function InvoiceFeatures_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InvoiceFeatures_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKInvoiceFeatures InvoiceFeatures_clone(const struct LDKInvoiceFeatures *NONNULL_PTR orig);
export function InvoiceFeatures_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ShutdownScript_free(this_obj);
// debug statements here
}
+ // uint64_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
+ export function ShutdownScript_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ShutdownScript_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
export function ShutdownScript_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.InvalidShutdownScript_new(encodeArray(script_arg));
return nativeResponseValue;
}
+ // uint64_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
+ export function InvalidShutdownScript_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InvalidShutdownScript_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
export function InvalidShutdownScript_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CustomMessageReader_free(this_ptr);
// debug statements here
}
+ // uint64_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
+ export function Type_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Type_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
export function Type_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.NodeId_free(this_obj);
// debug statements here
}
+ // uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
+ export function NodeId_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NodeId_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
export function NodeId_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.NetworkGraph_free(this_obj);
// debug statements here
}
+ // uint64_t NetworkGraph_clone_ptr(LDKNetworkGraph *NONNULL_PTR arg);
+ export function NetworkGraph_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NetworkGraph_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKNetworkGraph NetworkGraph_clone(const struct LDKNetworkGraph *NONNULL_PTR orig);
export function NetworkGraph_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.NetworkUpdate_free(this_ptr);
// debug statements here
}
+ // uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
+ export function NetworkUpdate_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NetworkUpdate_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
export function NetworkUpdate_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.NetworkUpdate_write(obj);
return decodeArray(nativeResponseValue);
}
+ // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
+ export function NetworkUpdate_read(ser: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NetworkUpdate_read(encodeArray(ser));
+ return nativeResponseValue;
+ }
// struct LDKEventHandler NetGraphMsgHandler_as_EventHandler(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
export function NetGraphMsgHandler_as_EventHandler(this_arg: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.DirectionalChannelInfo_new(last_update_arg, enabled_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg, fees_arg, last_update_message_arg);
return nativeResponseValue;
}
+ // uint64_t DirectionalChannelInfo_clone_ptr(LDKDirectionalChannelInfo *NONNULL_PTR arg);
+ export function DirectionalChannelInfo_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.DirectionalChannelInfo_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKDirectionalChannelInfo DirectionalChannelInfo_clone(const struct LDKDirectionalChannelInfo *NONNULL_PTR orig);
export function DirectionalChannelInfo_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelInfo_new(features_arg, node_one_arg, one_to_two_arg, node_two_arg, two_to_one_arg, capacity_sats_arg, announcement_message_arg);
return nativeResponseValue;
}
+ // uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
+ export function ChannelInfo_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelInfo_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
export function ChannelInfo_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.RoutingFees_eq(a, b);
return nativeResponseValue;
}
+ // uint64_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
+ export function RoutingFees_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.RoutingFees_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
export function RoutingFees_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.NodeAnnouncementInfo_new(features_arg, last_update_arg, encodeArray(rgb_arg), encodeArray(alias_arg), addresses_arg, announcement_message_arg);
return nativeResponseValue;
}
+ // uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
+ export function NodeAnnouncementInfo_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NodeAnnouncementInfo_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
export function NodeAnnouncementInfo_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.NodeInfo_new(channels_arg, lowest_inbound_channel_fees_arg, announcement_info_arg);
return nativeResponseValue;
}
+ // uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
+ export function NodeInfo_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NodeInfo_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
export function NodeInfo_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.RouteHop_new(encodeArray(pubkey_arg), node_features_arg, short_channel_id_arg, channel_features_arg, fee_msat_arg, cltv_expiry_delta_arg);
return nativeResponseValue;
}
+ // uint64_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
+ export function RouteHop_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.RouteHop_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
export function RouteHop_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.Route_new(paths_arg, payee_arg);
return nativeResponseValue;
}
+ // uint64_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
+ export function Route_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Route_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
export function Route_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.RouteParameters_new(payee_arg, final_value_msat_arg, final_cltv_expiry_delta_arg);
return nativeResponseValue;
}
+ // uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
+ export function RouteParameters_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.RouteParameters_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
export function RouteParameters_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.Payee_new(encodeArray(pubkey_arg), features_arg, route_hints_arg, expiry_time_arg);
return nativeResponseValue;
}
+ // uint64_t Payee_clone_ptr(LDKPayee *NONNULL_PTR arg);
+ export function Payee_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Payee_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKPayee Payee_clone(const struct LDKPayee *NONNULL_PTR orig);
export function Payee_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.RouteHint_new(a_arg);
return nativeResponseValue;
}
+ // uint64_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
+ export function RouteHint_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.RouteHint_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
export function RouteHint_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.RouteHintHop_new(encodeArray(src_node_id_arg), short_channel_id_arg, fees_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg);
return nativeResponseValue;
}
+ // uint64_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
+ export function RouteHintHop_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.RouteHintHop_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
export function RouteHintHop_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.Invoice_eq(a, b);
return nativeResponseValue;
}
+ // uint64_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg);
+ export function Invoice_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Invoice_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKInvoice Invoice_clone(const struct LDKInvoice *NONNULL_PTR orig);
export function Invoice_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.SignedRawInvoice_eq(a, b);
return nativeResponseValue;
}
+ // uint64_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg);
+ export function SignedRawInvoice_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SignedRawInvoice_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKSignedRawInvoice SignedRawInvoice_clone(const struct LDKSignedRawInvoice *NONNULL_PTR orig);
export function SignedRawInvoice_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.RawInvoice_eq(a, b);
return nativeResponseValue;
}
+ // uint64_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg);
+ export function RawInvoice_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.RawInvoice_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKRawInvoice RawInvoice_clone(const struct LDKRawInvoice *NONNULL_PTR orig);
export function RawInvoice_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.RawDataPart_eq(a, b);
return nativeResponseValue;
}
+ // uint64_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg);
+ export function RawDataPart_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.RawDataPart_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
export function RawDataPart_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.PositiveTimestamp_eq(a, b);
return nativeResponseValue;
}
+ // uint64_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg);
+ export function PositiveTimestamp_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.PositiveTimestamp_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
export function PositiveTimestamp_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.Sha256_free(this_obj);
// debug statements here
}
+ // uint64_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg);
+ export function Sha256_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Sha256_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
export function Sha256_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.Description_free(this_obj);
// debug statements here
}
+ // uint64_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg);
+ export function Description_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Description_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
export function Description_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.PayeePubKey_new(encodeArray(a_arg));
return nativeResponseValue;
}
+ // uint64_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg);
+ export function PayeePubKey_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.PayeePubKey_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
export function PayeePubKey_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ExpiryTime_free(this_obj);
// debug statements here
}
+ // uint64_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg);
+ export function ExpiryTime_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ExpiryTime_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
export function ExpiryTime_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.MinFinalCltvExpiry_new(a_arg);
return nativeResponseValue;
}
+ // uint64_t MinFinalCltvExpiry_clone_ptr(LDKMinFinalCltvExpiry *NONNULL_PTR arg);
+ export function MinFinalCltvExpiry_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.MinFinalCltvExpiry_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_clone(const struct LDKMinFinalCltvExpiry *NONNULL_PTR orig);
export function MinFinalCltvExpiry_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.Fallback_free(this_ptr);
// debug statements here
}
+ // uint64_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg);
+ export function Fallback_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Fallback_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKFallback Fallback_clone(const struct LDKFallback *NONNULL_PTR orig);
export function Fallback_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.InvoiceSignature_free(this_obj);
// debug statements here
}
+ // uint64_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg);
+ export function InvoiceSignature_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InvoiceSignature_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKInvoiceSignature InvoiceSignature_clone(const struct LDKInvoiceSignature *NONNULL_PTR orig);
export function InvoiceSignature_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.PrivateRoute_free(this_obj);
// debug statements here
}
+ // uint64_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg);
+ export function PrivateRoute_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.PrivateRoute_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
export function PrivateRoute_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.SignOrCreationError_free(this_ptr);
// debug statements here
}
+ // uint64_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg);
+ export function SignOrCreationError_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SignOrCreationError_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKSignOrCreationError SignOrCreationError_clone(const struct LDKSignOrCreationError *NONNULL_PTR orig);
export function SignOrCreationError_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.RetryAttempts_new(a_arg);
return nativeResponseValue;
}
+ // uint64_t RetryAttempts_clone_ptr(LDKRetryAttempts *NONNULL_PTR arg);
+ export function RetryAttempts_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.RetryAttempts_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKRetryAttempts RetryAttempts_clone(const struct LDKRetryAttempts *NONNULL_PTR orig);
export function RetryAttempts_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.PaymentError_free(this_ptr);
// debug statements here
}
+ // uint64_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg);
+ export function PaymentError_clone_ptr(arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.PaymentError_clone_ptr(arg);
+ return nativeResponseValue;
+ }
// struct LDKPaymentError PaymentError_clone(const struct LDKPaymentError *NONNULL_PTR orig);
export function PaymentError_clone(orig: number): number {
if(!isWasmInitialized) {
export enum AccessError {
- LDKAccessError_UnknownChain,
- LDKAccessError_UnknownTx,
+ /**
+ * The requested chain is unknown.
+ */
+LDKAccessError_UnknownChain,
+ /**
+ * The requested transaction doesn't exist or hasn't confirmed.
+ */
+LDKAccessError_UnknownTx,
}
export enum ChannelMonitorUpdateErr {
- LDKChannelMonitorUpdateErr_TemporaryFailure,
- LDKChannelMonitorUpdateErr_PermanentFailure,
+ /**
+ * Used to indicate a temporary failure (eg connection to a watchtower or remote backup of
+our state failed, but is expected to succeed at some point in the future).
+
+Such a failure will \"freeze\" a channel, preventing us from revoking old states or
+submitting new commitment transactions to the counterparty. Once the update(s) that failed
+have been successfully applied, a [`MonitorEvent::UpdateCompleted`] event should be returned
+via [`Watch::release_pending_monitor_events`] which will then restore the channel to an
+operational state.
+
+Note that a given ChannelManager will *never* re-generate a given ChannelMonitorUpdate. If
+you return a TemporaryFailure you must ensure that it is written to disk safely before
+writing out the latest ChannelManager state.
+
+Even when a channel has been \"frozen\" updates to the ChannelMonitor can continue to occur
+(eg if an inbound HTLC which we forwarded was claimed upstream resulting in us attempting
+to claim it on this channel) and those updates must be applied wherever they can be. At
+least one such updated ChannelMonitor must be persisted otherwise PermanentFailure should
+be returned to get things on-chain ASAP using only the in-memory copy. Obviously updates to
+the channel which would invalidate previous ChannelMonitors are not made when a channel has
+been \"frozen\".
+
+Note that even if updates made after TemporaryFailure succeed you must still provide a
+[`MonitorEvent::UpdateCompleted`] to ensure you have the latest monitor and re-enable
+normal channel operation. Note that this is normally generated through a call to
+[`ChainMonitor::channel_monitor_updated`].
+
+Note that the update being processed here will not be replayed for you when you return a
+[`MonitorEvent::UpdateCompleted`] event via [`Watch::release_pending_monitor_events`], so
+you must store the update itself on your own local disk prior to returning a
+TemporaryFailure. You may, of course, employ a journaling approach, storing only the
+ChannelMonitorUpdate on disk without updating the monitor itself, replaying the journal at
+reload-time.
+
+For deployments where a copy of ChannelMonitors and other local state are backed up in a
+remote location (with local copies persisted immediately), it is anticipated that all
+updates will return TemporaryFailure until the remote copies could be updated.
+
+[`ChainMonitor::channel_monitor_updated`]: chainmonitor::ChainMonitor::channel_monitor_updated
+ */
+LDKChannelMonitorUpdateErr_TemporaryFailure,
+ /**
+ * Used to indicate no further channel monitor updates will be allowed (eg we've moved on to a
+different watchtower and cannot update with all watchtowers that were previously informed
+of this channel).
+
+At reception of this error, ChannelManager will force-close the channel and return at
+least a final ChannelMonitorUpdate::ChannelForceClosed which must be delivered to at
+least one ChannelMonitor copy. Revocation secret MUST NOT be released and offchain channel
+update must be rejected.
+
+This failure may also signal a failure to update the local persisted copy of one of
+the channel monitor instance.
+
+Note that even when you fail a holder commitment transaction update, you must store the
+update to ensure you can claim from it in case of a duplicate copy of this ChannelMonitor
+broadcasts it (e.g distributed channel-monitor deployment)
+
+In case of distributed watchtowers deployment, the new version must be written to disk, as
+state may have been stored but rejected due to a block forcing a commitment broadcast. This
+storage is used to claim outputs of rejected state confirmed onchain by another watchtower,
+lagging behind on block processing.
+ */
+LDKChannelMonitorUpdateErr_PermanentFailure,
}
export enum ConfirmationTarget {
- LDKConfirmationTarget_Background,
- LDKConfirmationTarget_Normal,
- LDKConfirmationTarget_HighPriority,
+ /**
+ * We are happy with this transaction confirming slowly when feerate drops some.
+ */
+LDKConfirmationTarget_Background,
+ /**
+ * We'd like this transaction to confirm without major delay, but 12-18 blocks is fine.
+ */
+LDKConfirmationTarget_Normal,
+ /**
+ * We'd like this transaction to confirm in the next few blocks.
+ */
+LDKConfirmationTarget_HighPriority,
}
export enum CreationError {
- LDKCreationError_DescriptionTooLong,
- LDKCreationError_RouteTooLong,
- LDKCreationError_TimestampOutOfBounds,
- LDKCreationError_ExpiryTimeOutOfBounds,
+ /**
+ * The supplied description string was longer than 639 __bytes__ (see [`Description::new(...)`](./struct.Description.html#method.new))
+ */
+LDKCreationError_DescriptionTooLong,
+ /**
+ * The specified route has too many hops and can't be encoded
+ */
+LDKCreationError_RouteTooLong,
+ /**
+ * The unix timestamp of the supplied date is <0 or can't be represented as `SystemTime`
+ */
+LDKCreationError_TimestampOutOfBounds,
+ /**
+ * The supplied expiry time could cause an overflow if added to a `PositiveTimestamp`
+ */
+LDKCreationError_ExpiryTimeOutOfBounds,
}
export enum Currency {
- LDKCurrency_Bitcoin,
- LDKCurrency_BitcoinTestnet,
- LDKCurrency_Regtest,
- LDKCurrency_Simnet,
- LDKCurrency_Signet,
+ /**
+ * Bitcoin mainnet
+ */
+LDKCurrency_Bitcoin,
+ /**
+ * Bitcoin testnet
+ */
+LDKCurrency_BitcoinTestnet,
+ /**
+ * Bitcoin regtest
+ */
+LDKCurrency_Regtest,
+ /**
+ * Bitcoin simnet
+ */
+LDKCurrency_Simnet,
+ /**
+ * Bitcoin signet
+ */
+LDKCurrency_Signet,
}
export enum Level {
- LDKLevel_Trace,
- LDKLevel_Debug,
- LDKLevel_Info,
- LDKLevel_Warn,
- LDKLevel_Error,
+ /**
+ * Designates very low priority, often extremely verbose, information
+ */
+LDKLevel_Trace,
+ /**
+ * Designates lower priority information
+ */
+LDKLevel_Debug,
+ /**
+ * Designates useful information
+ */
+LDKLevel_Info,
+ /**
+ * Designates hazardous situations
+ */
+LDKLevel_Warn,
+ /**
+ * Designates very serious errors
+ */
+LDKLevel_Error,
}
export enum Network {
- LDKNetwork_Bitcoin,
- LDKNetwork_Testnet,
- LDKNetwork_Regtest,
- LDKNetwork_Signet,
+ /**
+ * The main Bitcoin blockchain.
+ */
+LDKNetwork_Bitcoin,
+ /**
+ * The testnet3 blockchain.
+ */
+LDKNetwork_Testnet,
+ /**
+ * A local test blockchain.
+ */
+LDKNetwork_Regtest,
+ /**
+ * A blockchain on which blocks are signed instead of mined.
+ */
+LDKNetwork_Signet,
}
export enum Secp256k1Error {
- LDKSecp256k1Error_IncorrectSignature,
- LDKSecp256k1Error_InvalidMessage,
- LDKSecp256k1Error_InvalidPublicKey,
- LDKSecp256k1Error_InvalidSignature,
- LDKSecp256k1Error_InvalidSecretKey,
- LDKSecp256k1Error_InvalidRecoveryId,
- LDKSecp256k1Error_InvalidTweak,
- LDKSecp256k1Error_TweakCheckFailed,
- LDKSecp256k1Error_NotEnoughMemory,
+ /**
+ * Signature failed verification
+ */
+LDKSecp256k1Error_IncorrectSignature,
+ /**
+ * Badly sized message ("messages" are actually fixed-sized digests; see the MESSAGE_SIZE constant)
+ */
+LDKSecp256k1Error_InvalidMessage,
+ /**
+ * Bad public key
+ */
+LDKSecp256k1Error_InvalidPublicKey,
+ /**
+ * Bad signature
+ */
+LDKSecp256k1Error_InvalidSignature,
+ /**
+ * Bad secret key
+ */
+LDKSecp256k1Error_InvalidSecretKey,
+ /**
+ * Bad recovery id
+ */
+LDKSecp256k1Error_InvalidRecoveryId,
+ /**
+ * Invalid tweak for add_assign or mul_assign
+ */
+LDKSecp256k1Error_InvalidTweak,
+ /**
+ * tweak_add_check failed on an xonly public key
+ */
+LDKSecp256k1Error_TweakCheckFailed,
+ /**
+ * Didn't pass enough memory to context creation with preallocated memory
+ */
+LDKSecp256k1Error_NotEnoughMemory,
}
export enum SemanticError {
- LDKSemanticError_NoPaymentHash,
- LDKSemanticError_MultiplePaymentHashes,
- LDKSemanticError_NoDescription,
- LDKSemanticError_MultipleDescriptions,
- LDKSemanticError_NoPaymentSecret,
- LDKSemanticError_MultiplePaymentSecrets,
- LDKSemanticError_InvalidFeatures,
- LDKSemanticError_InvalidRecoveryId,
- LDKSemanticError_InvalidSignature,
- LDKSemanticError_ImpreciseAmount,
+ /**
+ * The invoice is missing the mandatory payment hash
+ */
+LDKSemanticError_NoPaymentHash,
+ /**
+ * The invoice has multiple payment hashes which isn't allowed
+ */
+LDKSemanticError_MultiplePaymentHashes,
+ /**
+ * No description or description hash are part of the invoice
+ */
+LDKSemanticError_NoDescription,
+ /**
+ * The invoice contains multiple descriptions and/or description hashes which isn't allowed
+ */
+LDKSemanticError_MultipleDescriptions,
+ /**
+ * The invoice is missing the mandatory payment secret, which all modern lightning nodes
+should provide.
+ */
+LDKSemanticError_NoPaymentSecret,
+ /**
+ * The invoice contains multiple payment secrets
+ */
+LDKSemanticError_MultiplePaymentSecrets,
+ /**
+ * The invoice's features are invalid
+ */
+LDKSemanticError_InvalidFeatures,
+ /**
+ * The recovery id doesn't fit the signature/pub key
+ */
+LDKSemanticError_InvalidRecoveryId,
+ /**
+ * The invoice's signature is invalid
+ */
+LDKSemanticError_InvalidSignature,
+ /**
+ * The invoice's amount was not a whole number of millisatoshis
+ */
+LDKSemanticError_ImpreciseAmount,
}
export enum SiPrefix {
- LDKSiPrefix_Milli,
- LDKSiPrefix_Micro,
- LDKSiPrefix_Nano,
- LDKSiPrefix_Pico,
+ /**
+ * 10^-3
+ */
+LDKSiPrefix_Milli,
+ /**
+ * 10^-6
+ */
+LDKSiPrefix_Micro,
+ /**
+ * 10^-9
+ */
+LDKSiPrefix_Nano,
+ /**
+ * 10^-12
+ */
+LDKSiPrefix_Pico,
}
this.script = script_hu_conv;
}
}
+ public number clone_ptr() {
+ number ret = bindings.APIError_clone_ptr(this.ptr);
+ return ret;
+ }
+
public APIError clone() {
number ret = bindings.APIError_clone(this.ptr);
APIError ret_hu_conv = APIError.constr_from_ptr(ret);
}
public void set_temporary_channel_id(Uint8Array val) {
- bindings.AcceptChannel_set_temporary_channel_id(this.ptr, val);
+ bindings.AcceptChannel_set_temporary_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public number get_dust_limit_satoshis() {
}
public void set_funding_pubkey(Uint8Array val) {
- bindings.AcceptChannel_set_funding_pubkey(this.ptr, val);
+ bindings.AcceptChannel_set_funding_pubkey(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_revocation_basepoint() {
}
public void set_revocation_basepoint(Uint8Array val) {
- bindings.AcceptChannel_set_revocation_basepoint(this.ptr, val);
+ bindings.AcceptChannel_set_revocation_basepoint(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_payment_point() {
}
public void set_payment_point(Uint8Array val) {
- bindings.AcceptChannel_set_payment_point(this.ptr, val);
+ bindings.AcceptChannel_set_payment_point(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_delayed_payment_basepoint() {
}
public void set_delayed_payment_basepoint(Uint8Array val) {
- bindings.AcceptChannel_set_delayed_payment_basepoint(this.ptr, val);
+ bindings.AcceptChannel_set_delayed_payment_basepoint(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_htlc_basepoint() {
}
public void set_htlc_basepoint(Uint8Array val) {
- bindings.AcceptChannel_set_htlc_basepoint(this.ptr, val);
+ bindings.AcceptChannel_set_htlc_basepoint(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_first_per_commitment_point() {
}
public void set_first_per_commitment_point(Uint8Array val) {
- bindings.AcceptChannel_set_first_per_commitment_point(this.ptr, val);
+ bindings.AcceptChannel_set_first_per_commitment_point(this.ptr, InternalUtils.check_arr_len(val, 33));
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.AcceptChannel_clone_ptr(this.ptr);
+ return ret;
}
public AcceptChannel clone() {
// todo: in-line interface filling
get_utxo (genesis_hash: Uint8Array, short_channel_id: number): number {
Result_TxOutAccessErrorZ ret = arg.get_utxo(genesis_hash, short_channel_id);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
held: Access;
}
public Result_TxOutAccessErrorZ get_utxo(Uint8Array genesis_hash, number short_channel_id) {
- number ret = bindings.Access_get_utxo(this.ptr, genesis_hash, short_channel_id);
+ number ret = bindings.Access_get_utxo(this.ptr, InternalUtils.check_arr_len(genesis_hash, 32), short_channel_id);
Result_TxOutAccessErrorZ ret_hu_conv = Result_TxOutAccessErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
}
public void set_channel_id(Uint8Array val) {
- bindings.AnnouncementSignatures_set_channel_id(this.ptr, val);
+ bindings.AnnouncementSignatures_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public number get_short_channel_id() {
}
public void set_node_signature(Uint8Array val) {
- bindings.AnnouncementSignatures_set_node_signature(this.ptr, val);
+ bindings.AnnouncementSignatures_set_node_signature(this.ptr, InternalUtils.check_arr_len(val, 64));
}
public Uint8Array get_bitcoin_signature() {
}
public void set_bitcoin_signature(Uint8Array val) {
- bindings.AnnouncementSignatures_set_bitcoin_signature(this.ptr, val);
+ bindings.AnnouncementSignatures_set_bitcoin_signature(this.ptr, InternalUtils.check_arr_len(val, 64));
}
public static AnnouncementSignatures constructor_new(Uint8Array channel_id_arg, number short_channel_id_arg, Uint8Array node_signature_arg, Uint8Array bitcoin_signature_arg) {
- number ret = bindings.AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
+ number ret = bindings.AnnouncementSignatures_new(InternalUtils.check_arr_len(channel_id_arg, 32), short_channel_id_arg, InternalUtils.check_arr_len(node_signature_arg, 64), InternalUtils.check_arr_len(bitcoin_signature_arg, 64));
const ret_hu_conv: AnnouncementSignatures = new AnnouncementSignatures(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.AnnouncementSignatures_clone_ptr(this.ptr);
+ return ret;
+ }
+
public AnnouncementSignatures clone() {
number ret = bindings.AnnouncementSignatures_clone(this.ptr);
const ret_hu_conv: AnnouncementSignatures = new AnnouncementSignatures(null, ret);
this.claimable_height = obj.claimable_height;
}
}
+ public number clone_ptr() {
+ number ret = bindings.Balance_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Balance clone() {
number ret = bindings.Balance_clone(this.ptr);
Balance ret_hu_conv = Balance.constr_from_ptr(ret);
this.bindings_instance = null;
} else {
// TODO: private constructor instantiation
- super(bindings.LDKBaseSign_new(arg, pubkeys == null ? 0 : pubkeys.ptr & ~1));
+ super(bindings.LDKBaseSign_new(arg, pubkeys == null ? 0 : pubkeys.clone_ptr()));
this.ptrs_to.push(arg);
}
// todo: in-line interface filling
get_per_commitment_point (idx: number): Uint8Array {
Uint8Array ret = arg.get_per_commitment_point(idx);
- return ret;
+ result: Uint8Array = InternalUtils.check_arr_len(ret, 33);
+ return result;
},
release_commitment_secret (idx: number): Uint8Array {
Uint8Array ret = arg.release_commitment_secret(idx);
- return ret;
+ result: Uint8Array = InternalUtils.check_arr_len(ret, 32);
+ return result;
},
validate_holder_commitment (holder_tx: number): number {
const holder_tx_hu_conv: HolderCommitmentTransaction = new HolderCommitmentTransaction(null, holder_tx);
Result_NoneNoneZ ret = arg.validate_holder_commitment(holder_tx_hu_conv);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
channel_keys_id (): Uint8Array {
Uint8Array ret = arg.channel_keys_id();
- return ret;
+ result: Uint8Array = InternalUtils.check_arr_len(ret, 32);
+ return result;
},
sign_counterparty_commitment (commitment_tx: number): number {
const commitment_tx_hu_conv: CommitmentTransaction = new CommitmentTransaction(null, commitment_tx);
Result_C2Tuple_SignatureCVec_SignatureZZNoneZ ret = arg.sign_counterparty_commitment(commitment_tx_hu_conv);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
validate_counterparty_revocation (idx: number, secret: Uint8Array): number {
Result_NoneNoneZ ret = arg.validate_counterparty_revocation(idx, secret);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
sign_holder_commitment_and_htlcs (commitment_tx: number): number {
const commitment_tx_hu_conv: HolderCommitmentTransaction = new HolderCommitmentTransaction(null, commitment_tx);
Result_C2Tuple_SignatureCVec_SignatureZZNoneZ ret = arg.sign_holder_commitment_and_htlcs(commitment_tx_hu_conv);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
sign_justice_revoked_output (justice_tx: Uint8Array, input: number, amount: number, per_commitment_key: Uint8Array): number {
Result_SignatureNoneZ ret = arg.sign_justice_revoked_output(justice_tx, input, amount, per_commitment_key);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
sign_justice_revoked_htlc (justice_tx: Uint8Array, input: number, amount: number, per_commitment_key: Uint8Array, htlc: number): number {
const htlc_hu_conv: HTLCOutputInCommitment = new HTLCOutputInCommitment(null, htlc);
Result_SignatureNoneZ ret = arg.sign_justice_revoked_htlc(justice_tx, input, amount, per_commitment_key, htlc_hu_conv);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
sign_counterparty_htlc_transaction (htlc_tx: Uint8Array, input: number, amount: number, per_commitment_point: Uint8Array, htlc: number): number {
const htlc_hu_conv: HTLCOutputInCommitment = new HTLCOutputInCommitment(null, htlc);
Result_SignatureNoneZ ret = arg.sign_counterparty_htlc_transaction(htlc_tx, input, amount, per_commitment_point, htlc_hu_conv);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
sign_closing_transaction (closing_tx: number): number {
const closing_tx_hu_conv: ClosingTransaction = new ClosingTransaction(null, closing_tx);
Result_SignatureNoneZ ret = arg.sign_closing_transaction(closing_tx_hu_conv);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
sign_channel_announcement (msg: number): number {
const msg_hu_conv: UnsignedChannelAnnouncement = new UnsignedChannelAnnouncement(null, msg);
Result_SignatureNoneZ ret = arg.sign_channel_announcement(msg_hu_conv);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
}
public Result_NoneNoneZ validate_counterparty_revocation(number idx, Uint8Array secret) {
- number ret = bindings.BaseSign_validate_counterparty_revocation(this.ptr, idx, secret);
+ number ret = bindings.BaseSign_validate_counterparty_revocation(this.ptr, idx, InternalUtils.check_arr_len(secret, 32));
Result_NoneNoneZ ret_hu_conv = Result_NoneNoneZ.constr_from_ptr(ret);
return ret_hu_conv;
}
}
public Result_SignatureNoneZ sign_justice_revoked_output(Uint8Array justice_tx, number input, number amount, Uint8Array per_commitment_key) {
- number ret = bindings.BaseSign_sign_justice_revoked_output(this.ptr, justice_tx, input, amount, per_commitment_key);
+ number ret = bindings.BaseSign_sign_justice_revoked_output(this.ptr, justice_tx, input, amount, InternalUtils.check_arr_len(per_commitment_key, 32));
Result_SignatureNoneZ ret_hu_conv = Result_SignatureNoneZ.constr_from_ptr(ret);
return ret_hu_conv;
}
public Result_SignatureNoneZ sign_justice_revoked_htlc(Uint8Array justice_tx, number input, number amount, Uint8Array per_commitment_key, HTLCOutputInCommitment htlc) {
- number ret = bindings.BaseSign_sign_justice_revoked_htlc(this.ptr, justice_tx, input, amount, per_commitment_key, htlc == null ? 0 : htlc.ptr & ~1);
+ number ret = bindings.BaseSign_sign_justice_revoked_htlc(this.ptr, justice_tx, input, amount, InternalUtils.check_arr_len(per_commitment_key, 32), htlc == null ? 0 : htlc.ptr & ~1);
Result_SignatureNoneZ ret_hu_conv = Result_SignatureNoneZ.constr_from_ptr(ret);
this.ptrs_to.add(htlc);
return ret_hu_conv;
}
public Result_SignatureNoneZ sign_counterparty_htlc_transaction(Uint8Array htlc_tx, number input, number amount, Uint8Array per_commitment_point, HTLCOutputInCommitment htlc) {
- number ret = bindings.BaseSign_sign_counterparty_htlc_transaction(this.ptr, htlc_tx, input, amount, per_commitment_point, htlc == null ? 0 : htlc.ptr & ~1);
+ number ret = bindings.BaseSign_sign_counterparty_htlc_transaction(this.ptr, htlc_tx, input, amount, InternalUtils.check_arr_len(per_commitment_point, 33), htlc == null ? 0 : htlc.ptr & ~1);
Result_SignatureNoneZ ret_hu_conv = Result_SignatureNoneZ.constr_from_ptr(ret);
this.ptrs_to.add(htlc);
return ret_hu_conv;
bindings.BestBlock_free(this.ptr);
}
}
+ public number clone_ptr() {
+ number ret = bindings.BestBlock_clone_ptr(this.ptr);
+ return ret;
+ }
+
public BestBlock clone() {
number ret = bindings.BestBlock_clone(this.ptr);
const ret_hu_conv: BestBlock = new BestBlock(null, ret);
}
public static BestBlock constructor_new(Uint8Array block_hash, number height) {
- number ret = bindings.BestBlock_new(block_hash, height);
+ number ret = bindings.BestBlock_new(InternalUtils.check_arr_len(block_hash, 32), height);
const ret_hu_conv: BestBlock = new BestBlock(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public void set_txid(Uint8Array val) {
- bindings.BuiltCommitmentTransaction_set_txid(this.ptr, val);
+ bindings.BuiltCommitmentTransaction_set_txid(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public static BuiltCommitmentTransaction constructor_new(Uint8Array transaction_arg, Uint8Array txid_arg) {
- number ret = bindings.BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
+ number ret = bindings.BuiltCommitmentTransaction_new(transaction_arg, InternalUtils.check_arr_len(txid_arg, 32));
const ret_hu_conv: BuiltCommitmentTransaction = new BuiltCommitmentTransaction(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.BuiltCommitmentTransaction_clone_ptr(this.ptr);
+ return ret;
+ }
+
public BuiltCommitmentTransaction clone() {
number ret = bindings.BuiltCommitmentTransaction_clone(this.ptr);
const ret_hu_conv: BuiltCommitmentTransaction = new BuiltCommitmentTransaction(null, ret);
}
public Uint8Array sign(Uint8Array funding_key, Uint8Array funding_redeemscript, number channel_value_satoshis) {
- Uint8Array ret = bindings.BuiltCommitmentTransaction_sign(this.ptr, funding_key, funding_redeemscript, channel_value_satoshis);
+ Uint8Array ret = bindings.BuiltCommitmentTransaction_sign(this.ptr, InternalUtils.check_arr_len(funding_key, 32), funding_redeemscript, channel_value_satoshis);
return ret;
}
number ret = bindings.ChainMonitor_new(chain_source.ptr, broadcaster == null ? 0 : broadcaster.ptr, logger == null ? 0 : logger.ptr, feeest == null ? 0 : feeest.ptr, persister == null ? 0 : persister.ptr);
const ret_hu_conv: ChainMonitor = new ChainMonitor(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
+ ret_hu_conv.ptrs_to.add(chain_source);
ret_hu_conv.ptrs_to.add(broadcaster);
ret_hu_conv.ptrs_to.add(logger);
ret_hu_conv.ptrs_to.add(feeest);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.ChainParameters_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ChainParameters clone() {
number ret = bindings.ChainParameters_clone(this.ptr);
const ret_hu_conv: ChainParameters = new ChainParameters(null, ret);
}
public void set_node_signature_1(Uint8Array val) {
- bindings.ChannelAnnouncement_set_node_signature_1(this.ptr, val);
+ bindings.ChannelAnnouncement_set_node_signature_1(this.ptr, InternalUtils.check_arr_len(val, 64));
}
public Uint8Array get_node_signature_2() {
}
public void set_node_signature_2(Uint8Array val) {
- bindings.ChannelAnnouncement_set_node_signature_2(this.ptr, val);
+ bindings.ChannelAnnouncement_set_node_signature_2(this.ptr, InternalUtils.check_arr_len(val, 64));
}
public Uint8Array get_bitcoin_signature_1() {
}
public void set_bitcoin_signature_1(Uint8Array val) {
- bindings.ChannelAnnouncement_set_bitcoin_signature_1(this.ptr, val);
+ bindings.ChannelAnnouncement_set_bitcoin_signature_1(this.ptr, InternalUtils.check_arr_len(val, 64));
}
public Uint8Array get_bitcoin_signature_2() {
}
public void set_bitcoin_signature_2(Uint8Array val) {
- bindings.ChannelAnnouncement_set_bitcoin_signature_2(this.ptr, val);
+ bindings.ChannelAnnouncement_set_bitcoin_signature_2(this.ptr, InternalUtils.check_arr_len(val, 64));
}
public UnsignedChannelAnnouncement get_contents() {
}
public static ChannelAnnouncement constructor_new(Uint8Array node_signature_1_arg, Uint8Array node_signature_2_arg, Uint8Array bitcoin_signature_1_arg, Uint8Array bitcoin_signature_2_arg, UnsignedChannelAnnouncement contents_arg) {
- number ret = bindings.ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg == null ? 0 : contents_arg.ptr & ~1);
+ number ret = bindings.ChannelAnnouncement_new(InternalUtils.check_arr_len(node_signature_1_arg, 64), InternalUtils.check_arr_len(node_signature_2_arg, 64), InternalUtils.check_arr_len(bitcoin_signature_1_arg, 64), InternalUtils.check_arr_len(bitcoin_signature_2_arg, 64), contents_arg == null ? 0 : contents_arg.ptr & ~1);
const ret_hu_conv: ChannelAnnouncement = new ChannelAnnouncement(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.ChannelAnnouncement_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ChannelAnnouncement clone() {
number ret = bindings.ChannelAnnouncement_clone(this.ptr);
const ret_hu_conv: ChannelAnnouncement = new ChannelAnnouncement(null, ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.ChannelConfig_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ChannelConfig clone() {
number ret = bindings.ChannelConfig_clone(this.ptr);
const ret_hu_conv: ChannelConfig = new ChannelConfig(null, ret);
}
public void set_node_id(Uint8Array val) {
- bindings.ChannelCounterparty_set_node_id(this.ptr, val);
+ bindings.ChannelCounterparty_set_node_id(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public InitFeatures get_features() {
}
public static ChannelCounterparty constructor_new(Uint8Array node_id_arg, InitFeatures features_arg, number unspendable_punishment_reserve_arg, CounterpartyForwardingInfo forwarding_info_arg) {
- number ret = bindings.ChannelCounterparty_new(node_id_arg, features_arg == null ? 0 : features_arg.ptr & ~1, unspendable_punishment_reserve_arg, forwarding_info_arg == null ? 0 : forwarding_info_arg.ptr & ~1);
+ number ret = bindings.ChannelCounterparty_new(InternalUtils.check_arr_len(node_id_arg, 33), features_arg == null ? 0 : features_arg.ptr & ~1, unspendable_punishment_reserve_arg, forwarding_info_arg == null ? 0 : forwarding_info_arg.ptr & ~1);
const ret_hu_conv: ChannelCounterparty = new ChannelCounterparty(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.ChannelCounterparty_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ChannelCounterparty clone() {
number ret = bindings.ChannelCounterparty_clone(this.ptr);
const ret_hu_conv: ChannelCounterparty = new ChannelCounterparty(null, ret);
}
public void set_channel_id(Uint8Array val) {
- bindings.ChannelDetails_set_channel_id(this.ptr, val);
+ bindings.ChannelDetails_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public ChannelCounterparty get_counterparty() {
}
public static ChannelDetails constructor_new(Uint8Array channel_id_arg, ChannelCounterparty counterparty_arg, OutPoint funding_txo_arg, Option_u64Z short_channel_id_arg, number channel_value_satoshis_arg, Option_u64Z unspendable_punishment_reserve_arg, number user_channel_id_arg, number outbound_capacity_msat_arg, number inbound_capacity_msat_arg, Option_u32Z confirmations_required_arg, Option_u16Z force_close_spend_delay_arg, boolean is_outbound_arg, boolean is_funding_locked_arg, boolean is_usable_arg, boolean is_public_arg) {
- number ret = bindings.ChannelDetails_new(channel_id_arg, counterparty_arg == null ? 0 : counterparty_arg.ptr & ~1, funding_txo_arg == null ? 0 : funding_txo_arg.ptr & ~1, short_channel_id_arg.ptr, channel_value_satoshis_arg, unspendable_punishment_reserve_arg.ptr, user_channel_id_arg, outbound_capacity_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg.ptr, force_close_spend_delay_arg.ptr, is_outbound_arg, is_funding_locked_arg, is_usable_arg, is_public_arg);
+ number ret = bindings.ChannelDetails_new(InternalUtils.check_arr_len(channel_id_arg, 32), counterparty_arg == null ? 0 : counterparty_arg.ptr & ~1, funding_txo_arg == null ? 0 : funding_txo_arg.ptr & ~1, short_channel_id_arg.ptr, channel_value_satoshis_arg, unspendable_punishment_reserve_arg.ptr, user_channel_id_arg, outbound_capacity_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg.ptr, force_close_spend_delay_arg.ptr, is_outbound_arg, is_funding_locked_arg, is_usable_arg, is_public_arg);
const ret_hu_conv: ChannelDetails = new ChannelDetails(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.ChannelDetails_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ChannelDetails clone() {
number ret = bindings.ChannelDetails_clone(this.ptr);
const ret_hu_conv: ChannelDetails = new ChannelDetails(null, ret);
return ret;
}
+ public number clone_ptr() {
+ number ret = bindings.ChannelFeatures_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ChannelFeatures clone() {
number ret = bindings.ChannelFeatures_clone(this.ptr);
const ret_hu_conv: ChannelFeatures = new ChannelFeatures(null, ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.ChannelHandshakeConfig_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ChannelHandshakeConfig clone() {
number ret = bindings.ChannelHandshakeConfig_clone(this.ptr);
const ret_hu_conv: ChannelHandshakeConfig = new ChannelHandshakeConfig(null, ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.ChannelHandshakeLimits_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ChannelHandshakeLimits clone() {
number ret = bindings.ChannelHandshakeLimits_clone(this.ptr);
const ret_hu_conv: ChannelHandshakeLimits = new ChannelHandshakeLimits(null, ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.ChannelInfo_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ChannelInfo clone() {
number ret = bindings.ChannelInfo_clone(this.ptr);
const ret_hu_conv: ChannelInfo = new ChannelInfo(null, ret);
}
public Result__u832APIErrorZ create_channel(Uint8Array their_network_key, number channel_value_satoshis, number push_msat, number user_channel_id, UserConfig override_config) {
- number ret = bindings.ChannelManager_create_channel(this.ptr, their_network_key, channel_value_satoshis, push_msat, user_channel_id, override_config == null ? 0 : override_config.ptr & ~1);
+ number ret = bindings.ChannelManager_create_channel(this.ptr, InternalUtils.check_arr_len(their_network_key, 33), channel_value_satoshis, push_msat, user_channel_id, override_config == null ? 0 : override_config.ptr & ~1);
Result__u832APIErrorZ ret_hu_conv = Result__u832APIErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
}
public Result_NoneAPIErrorZ close_channel(Uint8Array channel_id) {
- number ret = bindings.ChannelManager_close_channel(this.ptr, channel_id);
+ number ret = bindings.ChannelManager_close_channel(this.ptr, InternalUtils.check_arr_len(channel_id, 32));
Result_NoneAPIErrorZ ret_hu_conv = Result_NoneAPIErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
public Result_NoneAPIErrorZ close_channel_with_target_feerate(Uint8Array channel_id, number target_feerate_sats_per_1000_weight) {
- number ret = bindings.ChannelManager_close_channel_with_target_feerate(this.ptr, channel_id, target_feerate_sats_per_1000_weight);
+ number ret = bindings.ChannelManager_close_channel_with_target_feerate(this.ptr, InternalUtils.check_arr_len(channel_id, 32), target_feerate_sats_per_1000_weight);
Result_NoneAPIErrorZ ret_hu_conv = Result_NoneAPIErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
public Result_NoneAPIErrorZ force_close_channel(Uint8Array channel_id) {
- number ret = bindings.ChannelManager_force_close_channel(this.ptr, channel_id);
+ number ret = bindings.ChannelManager_force_close_channel(this.ptr, InternalUtils.check_arr_len(channel_id, 32));
Result_NoneAPIErrorZ ret_hu_conv = Result_NoneAPIErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
}
public Result_PaymentIdPaymentSendFailureZ send_payment(Route route, Uint8Array payment_hash, Uint8Array payment_secret) {
- number ret = bindings.ChannelManager_send_payment(this.ptr, route == null ? 0 : route.ptr & ~1, payment_hash, payment_secret);
+ number ret = bindings.ChannelManager_send_payment(this.ptr, route == null ? 0 : route.ptr & ~1, InternalUtils.check_arr_len(payment_hash, 32), InternalUtils.check_arr_len(payment_secret, 32));
Result_PaymentIdPaymentSendFailureZ ret_hu_conv = Result_PaymentIdPaymentSendFailureZ.constr_from_ptr(ret);
this.ptrs_to.add(route);
return ret_hu_conv;
}
public Result_NonePaymentSendFailureZ retry_payment(Route route, Uint8Array payment_id) {
- number ret = bindings.ChannelManager_retry_payment(this.ptr, route == null ? 0 : route.ptr & ~1, payment_id);
+ number ret = bindings.ChannelManager_retry_payment(this.ptr, route == null ? 0 : route.ptr & ~1, InternalUtils.check_arr_len(payment_id, 32));
Result_NonePaymentSendFailureZ ret_hu_conv = Result_NonePaymentSendFailureZ.constr_from_ptr(ret);
this.ptrs_to.add(route);
return ret_hu_conv;
}
public Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ send_spontaneous_payment(Route route, Uint8Array payment_preimage) {
- number ret = bindings.ChannelManager_send_spontaneous_payment(this.ptr, route == null ? 0 : route.ptr & ~1, payment_preimage);
+ number ret = bindings.ChannelManager_send_spontaneous_payment(this.ptr, route == null ? 0 : route.ptr & ~1, InternalUtils.check_arr_len(payment_preimage, 32));
Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ ret_hu_conv = Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ.constr_from_ptr(ret);
this.ptrs_to.add(route);
return ret_hu_conv;
}
public Result_NoneAPIErrorZ funding_transaction_generated(Uint8Array temporary_channel_id, Uint8Array funding_transaction) {
- number ret = bindings.ChannelManager_funding_transaction_generated(this.ptr, temporary_channel_id, funding_transaction);
+ number ret = bindings.ChannelManager_funding_transaction_generated(this.ptr, InternalUtils.check_arr_len(temporary_channel_id, 32), funding_transaction);
Result_NoneAPIErrorZ ret_hu_conv = Result_NoneAPIErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
public void broadcast_node_announcement(Uint8Array rgb, Uint8Array alias, NetAddress[] addresses) {
- bindings.ChannelManager_broadcast_node_announcement(this.ptr, rgb, alias, addresses != null ? Arrays.stream(addresses).map(addresses_conv_12 -> addresses_conv_12.ptr).toArray(number[]::new) : null);
+ bindings.ChannelManager_broadcast_node_announcement(this.ptr, InternalUtils.check_arr_len(rgb, 3), InternalUtils.check_arr_len(alias, 32), addresses != null ? Arrays.stream(addresses).map(addresses_conv_12 -> addresses_conv_12.ptr).toArray(number[]::new) : null);
}
public void process_pending_htlc_forwards() {
}
public boolean fail_htlc_backwards(Uint8Array payment_hash) {
- boolean ret = bindings.ChannelManager_fail_htlc_backwards(this.ptr, payment_hash);
+ boolean ret = bindings.ChannelManager_fail_htlc_backwards(this.ptr, InternalUtils.check_arr_len(payment_hash, 32));
return ret;
}
public boolean claim_funds(Uint8Array payment_preimage) {
- boolean ret = bindings.ChannelManager_claim_funds(this.ptr, payment_preimage);
+ boolean ret = bindings.ChannelManager_claim_funds(this.ptr, InternalUtils.check_arr_len(payment_preimage, 32));
return ret;
}
}
public Result_PaymentSecretAPIErrorZ create_inbound_payment_for_hash(Uint8Array payment_hash, Option_u64Z min_value_msat, number invoice_expiry_delta_secs, number user_payment_id) {
- number ret = bindings.ChannelManager_create_inbound_payment_for_hash(this.ptr, payment_hash, min_value_msat.ptr, invoice_expiry_delta_secs, user_payment_id);
+ number ret = bindings.ChannelManager_create_inbound_payment_for_hash(this.ptr, InternalUtils.check_arr_len(payment_hash, 32), min_value_msat.ptr, invoice_expiry_delta_secs, user_payment_id);
Result_PaymentSecretAPIErrorZ ret_hu_conv = Result_PaymentSecretAPIErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
persist_manager (channel_manager: number): number {
const channel_manager_hu_conv: ChannelManager = new ChannelManager(null, channel_manager);
Result_NoneErrorZ ret = arg.persist_manager(channel_manager_hu_conv);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
held: ChannelMessageHandler;
}
public void handle_open_channel(Uint8Array their_node_id, InitFeatures their_features, OpenChannel msg) {
- bindings.ChannelMessageHandler_handle_open_channel(this.ptr, their_node_id, their_features == null ? 0 : their_features.ptr & ~1, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_open_channel(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), their_features == null ? 0 : their_features.ptr & ~1, msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
public void handle_accept_channel(Uint8Array their_node_id, InitFeatures their_features, AcceptChannel msg) {
- bindings.ChannelMessageHandler_handle_accept_channel(this.ptr, their_node_id, their_features == null ? 0 : their_features.ptr & ~1, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_accept_channel(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), their_features == null ? 0 : their_features.ptr & ~1, msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
public void handle_funding_created(Uint8Array their_node_id, FundingCreated msg) {
- bindings.ChannelMessageHandler_handle_funding_created(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_funding_created(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
public void handle_funding_signed(Uint8Array their_node_id, FundingSigned msg) {
- bindings.ChannelMessageHandler_handle_funding_signed(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_funding_signed(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
public void handle_funding_locked(Uint8Array their_node_id, FundingLocked msg) {
- bindings.ChannelMessageHandler_handle_funding_locked(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_funding_locked(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
public void handle_shutdown(Uint8Array their_node_id, InitFeatures their_features, Shutdown msg) {
- bindings.ChannelMessageHandler_handle_shutdown(this.ptr, their_node_id, their_features == null ? 0 : their_features.ptr & ~1, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_shutdown(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), their_features == null ? 0 : their_features.ptr & ~1, msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(their_features);
this.ptrs_to.add(msg);
}
public void handle_closing_signed(Uint8Array their_node_id, ClosingSigned msg) {
- bindings.ChannelMessageHandler_handle_closing_signed(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_closing_signed(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
public void handle_update_add_htlc(Uint8Array their_node_id, UpdateAddHTLC msg) {
- bindings.ChannelMessageHandler_handle_update_add_htlc(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_update_add_htlc(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
public void handle_update_fulfill_htlc(Uint8Array their_node_id, UpdateFulfillHTLC msg) {
- bindings.ChannelMessageHandler_handle_update_fulfill_htlc(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_update_fulfill_htlc(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
public void handle_update_fail_htlc(Uint8Array their_node_id, UpdateFailHTLC msg) {
- bindings.ChannelMessageHandler_handle_update_fail_htlc(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_update_fail_htlc(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
public void handle_update_fail_malformed_htlc(Uint8Array their_node_id, UpdateFailMalformedHTLC msg) {
- bindings.ChannelMessageHandler_handle_update_fail_malformed_htlc(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_update_fail_malformed_htlc(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
public void handle_commitment_signed(Uint8Array their_node_id, CommitmentSigned msg) {
- bindings.ChannelMessageHandler_handle_commitment_signed(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_commitment_signed(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
public void handle_revoke_and_ack(Uint8Array their_node_id, RevokeAndACK msg) {
- bindings.ChannelMessageHandler_handle_revoke_and_ack(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_revoke_and_ack(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
public void handle_update_fee(Uint8Array their_node_id, UpdateFee msg) {
- bindings.ChannelMessageHandler_handle_update_fee(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_update_fee(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
public void handle_announcement_signatures(Uint8Array their_node_id, AnnouncementSignatures msg) {
- bindings.ChannelMessageHandler_handle_announcement_signatures(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_announcement_signatures(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
public void peer_disconnected(Uint8Array their_node_id, boolean no_connection_possible) {
- bindings.ChannelMessageHandler_peer_disconnected(this.ptr, their_node_id, no_connection_possible);
+ bindings.ChannelMessageHandler_peer_disconnected(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), no_connection_possible);
}
public void peer_connected(Uint8Array their_node_id, Init msg) {
- bindings.ChannelMessageHandler_peer_connected(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_peer_connected(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
public void handle_channel_reestablish(Uint8Array their_node_id, ChannelReestablish msg) {
- bindings.ChannelMessageHandler_handle_channel_reestablish(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_channel_reestablish(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
public void handle_channel_update(Uint8Array their_node_id, ChannelUpdate msg) {
- bindings.ChannelMessageHandler_handle_channel_update(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_channel_update(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
public void handle_error(Uint8Array their_node_id, ErrorMessage msg) {
- bindings.ChannelMessageHandler_handle_error(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ bindings.ChannelMessageHandler_handle_error(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
this.ptrs_to.add(msg);
}
bindings.ChannelMonitor_free(this.ptr);
}
}
+ public number clone_ptr() {
+ number ret = bindings.ChannelMonitor_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ChannelMonitor clone() {
number ret = bindings.ChannelMonitor_clone(this.ptr);
const ret_hu_conv: ChannelMonitor = new ChannelMonitor(null, ret);
}
public TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[] block_connected(Uint8Array header, TwoTuple_usizeTransactionZ[] txdata, number height, BroadcasterInterface broadcaster, FeeEstimator fee_estimator, Logger logger) {
- number[] ret = bindings.ChannelMonitor_block_connected(this.ptr, header, txdata != null ? Arrays.stream(txdata).map(txdata_conv_28 -> txdata_conv_28 != null ? txdata_conv_28.ptr : 0).toArray(number[]::new) : null, height, broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr);
+ number[] ret = bindings.ChannelMonitor_block_connected(this.ptr, InternalUtils.check_arr_len(header, 80), txdata != null ? Arrays.stream(txdata).map(txdata_conv_28 -> txdata_conv_28 != null ? txdata_conv_28.ptr : 0).toArray(number[]::new) : null, height, broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr);
TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[] ret_conv_39_arr = new TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[ret.length];
for (int n = 0; n < ret.length; n++) {
number ret_conv_39 = ret[n];
}
public void block_disconnected(Uint8Array header, number height, BroadcasterInterface broadcaster, FeeEstimator fee_estimator, Logger logger) {
- bindings.ChannelMonitor_block_disconnected(this.ptr, header, height, broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr);
+ bindings.ChannelMonitor_block_disconnected(this.ptr, InternalUtils.check_arr_len(header, 80), height, broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr);
this.ptrs_to.add(broadcaster);
this.ptrs_to.add(fee_estimator);
this.ptrs_to.add(logger);
}
public TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[] transactions_confirmed(Uint8Array header, TwoTuple_usizeTransactionZ[] txdata, number height, BroadcasterInterface broadcaster, FeeEstimator fee_estimator, Logger logger) {
- number[] ret = bindings.ChannelMonitor_transactions_confirmed(this.ptr, header, txdata != null ? Arrays.stream(txdata).map(txdata_conv_28 -> txdata_conv_28 != null ? txdata_conv_28.ptr : 0).toArray(number[]::new) : null, height, broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr);
+ number[] ret = bindings.ChannelMonitor_transactions_confirmed(this.ptr, InternalUtils.check_arr_len(header, 80), txdata != null ? Arrays.stream(txdata).map(txdata_conv_28 -> txdata_conv_28 != null ? txdata_conv_28.ptr : 0).toArray(number[]::new) : null, height, broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr);
TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[] ret_conv_39_arr = new TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[ret.length];
for (int n = 0; n < ret.length; n++) {
number ret_conv_39 = ret[n];
}
public void transaction_unconfirmed(Uint8Array txid, BroadcasterInterface broadcaster, FeeEstimator fee_estimator, Logger logger) {
- bindings.ChannelMonitor_transaction_unconfirmed(this.ptr, txid, broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr);
+ bindings.ChannelMonitor_transaction_unconfirmed(this.ptr, InternalUtils.check_arr_len(txid, 32), broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr);
this.ptrs_to.add(broadcaster);
this.ptrs_to.add(fee_estimator);
this.ptrs_to.add(logger);
}
public TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[] best_block_updated(Uint8Array header, number height, BroadcasterInterface broadcaster, FeeEstimator fee_estimator, Logger logger) {
- number[] ret = bindings.ChannelMonitor_best_block_updated(this.ptr, header, height, broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr);
+ number[] ret = bindings.ChannelMonitor_best_block_updated(this.ptr, InternalUtils.check_arr_len(header, 80), height, broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr);
TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[] ret_conv_39_arr = new TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[ret.length];
for (int n = 0; n < ret.length; n++) {
number ret_conv_39 = ret[n];
bindings.ChannelMonitorUpdate_set_update_id(this.ptr, val);
}
+ public number clone_ptr() {
+ number ret = bindings.ChannelMonitorUpdate_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ChannelMonitorUpdate clone() {
number ret = bindings.ChannelMonitorUpdate_clone(this.ptr);
const ret_hu_conv: ChannelMonitorUpdate = new ChannelMonitorUpdate(null, ret);
}
public void set_funding_pubkey(Uint8Array val) {
- bindings.ChannelPublicKeys_set_funding_pubkey(this.ptr, val);
+ bindings.ChannelPublicKeys_set_funding_pubkey(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_revocation_basepoint() {
}
public void set_revocation_basepoint(Uint8Array val) {
- bindings.ChannelPublicKeys_set_revocation_basepoint(this.ptr, val);
+ bindings.ChannelPublicKeys_set_revocation_basepoint(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_payment_point() {
}
public void set_payment_point(Uint8Array val) {
- bindings.ChannelPublicKeys_set_payment_point(this.ptr, val);
+ bindings.ChannelPublicKeys_set_payment_point(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_delayed_payment_basepoint() {
}
public void set_delayed_payment_basepoint(Uint8Array val) {
- bindings.ChannelPublicKeys_set_delayed_payment_basepoint(this.ptr, val);
+ bindings.ChannelPublicKeys_set_delayed_payment_basepoint(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_htlc_basepoint() {
}
public void set_htlc_basepoint(Uint8Array val) {
- bindings.ChannelPublicKeys_set_htlc_basepoint(this.ptr, val);
+ bindings.ChannelPublicKeys_set_htlc_basepoint(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public static ChannelPublicKeys constructor_new(Uint8Array funding_pubkey_arg, Uint8Array revocation_basepoint_arg, Uint8Array payment_point_arg, Uint8Array delayed_payment_basepoint_arg, Uint8Array htlc_basepoint_arg) {
- number ret = bindings.ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
+ number ret = bindings.ChannelPublicKeys_new(InternalUtils.check_arr_len(funding_pubkey_arg, 33), InternalUtils.check_arr_len(revocation_basepoint_arg, 33), InternalUtils.check_arr_len(payment_point_arg, 33), InternalUtils.check_arr_len(delayed_payment_basepoint_arg, 33), InternalUtils.check_arr_len(htlc_basepoint_arg, 33));
const ret_hu_conv: ChannelPublicKeys = new ChannelPublicKeys(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.ChannelPublicKeys_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ChannelPublicKeys clone() {
number ret = bindings.ChannelPublicKeys_clone(this.ptr);
const ret_hu_conv: ChannelPublicKeys = new ChannelPublicKeys(null, ret);
}
public void set_channel_id(Uint8Array val) {
- bindings.ChannelReestablish_set_channel_id(this.ptr, val);
+ bindings.ChannelReestablish_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public number get_next_local_commitment_number() {
bindings.ChannelReestablish_set_next_remote_commitment_number(this.ptr, val);
}
+ public number clone_ptr() {
+ number ret = bindings.ChannelReestablish_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ChannelReestablish clone() {
number ret = bindings.ChannelReestablish_clone(this.ptr);
const ret_hu_conv: ChannelReestablish = new ChannelReestablish(null, ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.ChannelTransactionParameters_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ChannelTransactionParameters clone() {
number ret = bindings.ChannelTransactionParameters_clone(this.ptr);
const ret_hu_conv: ChannelTransactionParameters = new ChannelTransactionParameters(null, ret);
}
public void set_signature(Uint8Array val) {
- bindings.ChannelUpdate_set_signature(this.ptr, val);
+ bindings.ChannelUpdate_set_signature(this.ptr, InternalUtils.check_arr_len(val, 64));
}
public UnsignedChannelUpdate get_contents() {
}
public static ChannelUpdate constructor_new(Uint8Array signature_arg, UnsignedChannelUpdate contents_arg) {
- number ret = bindings.ChannelUpdate_new(signature_arg, contents_arg == null ? 0 : contents_arg.ptr & ~1);
+ number ret = bindings.ChannelUpdate_new(InternalUtils.check_arr_len(signature_arg, 64), contents_arg == null ? 0 : contents_arg.ptr & ~1);
const ret_hu_conv: ChannelUpdate = new ChannelUpdate(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.ChannelUpdate_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ChannelUpdate clone() {
number ret = bindings.ChannelUpdate_clone(this.ptr);
const ret_hu_conv: ChannelUpdate = new ChannelUpdate(null, ret);
}
public void set_channel_id(Uint8Array val) {
- bindings.ClosingSigned_set_channel_id(this.ptr, val);
+ bindings.ClosingSigned_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public number get_fee_satoshis() {
}
public void set_signature(Uint8Array val) {
- bindings.ClosingSigned_set_signature(this.ptr, val);
+ bindings.ClosingSigned_set_signature(this.ptr, InternalUtils.check_arr_len(val, 64));
}
public ClosingSignedFeeRange get_fee_range() {
}
public static ClosingSigned constructor_new(Uint8Array channel_id_arg, number fee_satoshis_arg, Uint8Array signature_arg, ClosingSignedFeeRange fee_range_arg) {
- number ret = bindings.ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg == null ? 0 : fee_range_arg.ptr & ~1);
+ number ret = bindings.ClosingSigned_new(InternalUtils.check_arr_len(channel_id_arg, 32), fee_satoshis_arg, InternalUtils.check_arr_len(signature_arg, 64), fee_range_arg == null ? 0 : fee_range_arg.ptr & ~1);
const ret_hu_conv: ClosingSigned = new ClosingSigned(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.ClosingSigned_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ClosingSigned clone() {
number ret = bindings.ClosingSigned_clone(this.ptr);
const ret_hu_conv: ClosingSigned = new ClosingSigned(null, ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.ClosingSignedFeeRange_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ClosingSignedFeeRange clone() {
number ret = bindings.ClosingSignedFeeRange_clone(this.ptr);
const ret_hu_conv: ClosingSignedFeeRange = new ClosingSignedFeeRange(null, ret);
bindings.ClosingTransaction_free(this.ptr);
}
}
+ public number clone_ptr() {
+ number ret = bindings.ClosingTransaction_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ClosingTransaction clone() {
number ret = bindings.ClosingTransaction_clone(this.ptr);
const ret_hu_conv: ClosingTransaction = new ClosingTransaction(null, ret);
super(null, ptr);
}
}
+ public number clone_ptr() {
+ number ret = bindings.ClosureReason_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ClosureReason clone() {
number ret = bindings.ClosureReason_clone(this.ptr);
ClosureReason ret_hu_conv = ClosureReason.constr_from_ptr(ret);
}
public void set_channel_id(Uint8Array val) {
- bindings.CommitmentSigned_set_channel_id(this.ptr, val);
+ bindings.CommitmentSigned_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public Uint8Array get_signature() {
}
public void set_signature(Uint8Array val) {
- bindings.CommitmentSigned_set_signature(this.ptr, val);
+ bindings.CommitmentSigned_set_signature(this.ptr, InternalUtils.check_arr_len(val, 64));
}
public void set_htlc_signatures(Uint8Array[] val) {
- bindings.CommitmentSigned_set_htlc_signatures(this.ptr, val);
+ bindings.CommitmentSigned_set_htlc_signatures(this.ptr, val != null ? Arrays.stream(val).map(val_conv_12 -> InternalUtils.check_arr_len(val_conv_12, 64)).toArray(Uint8Array[]::new) : null);
}
public static CommitmentSigned constructor_new(Uint8Array channel_id_arg, Uint8Array signature_arg, Uint8Array[] htlc_signatures_arg) {
- number ret = bindings.CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
+ number ret = bindings.CommitmentSigned_new(InternalUtils.check_arr_len(channel_id_arg, 32), InternalUtils.check_arr_len(signature_arg, 64), htlc_signatures_arg != null ? Arrays.stream(htlc_signatures_arg).map(htlc_signatures_arg_conv_12 -> InternalUtils.check_arr_len(htlc_signatures_arg_conv_12, 64)).toArray(Uint8Array[]::new) : null);
const ret_hu_conv: CommitmentSigned = new CommitmentSigned(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.CommitmentSigned_clone_ptr(this.ptr);
+ return ret;
+ }
+
public CommitmentSigned clone() {
number ret = bindings.CommitmentSigned_clone(this.ptr);
const ret_hu_conv: CommitmentSigned = new CommitmentSigned(null, ret);
bindings.CommitmentTransaction_free(this.ptr);
}
}
+ public number clone_ptr() {
+ number ret = bindings.CommitmentTransaction_clone_ptr(this.ptr);
+ return ret;
+ }
+
public CommitmentTransaction clone() {
number ret = bindings.CommitmentTransaction_clone(this.ptr);
const ret_hu_conv: CommitmentTransaction = new CommitmentTransaction(null, ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.CommitmentUpdate_clone_ptr(this.ptr);
+ return ret;
+ }
+
public CommitmentUpdate clone() {
number ret = bindings.CommitmentUpdate_clone(this.ptr);
const ret_hu_conv: CommitmentUpdate = new CommitmentUpdate(null, ret);
get_relevant_txids (): Uint8Array[] {
Uint8Array[] ret = arg.get_relevant_txids();
- return ret;
+ result: Uint8Array[] = ret != null ? Arrays.stream(ret).map(ret_conv_12 -> InternalUtils.check_arr_len(ret_conv_12, 32)).toArray(Uint8Array[]::new) : null;
+ return result;
},
held: Confirm;
}
public void transactions_confirmed(Uint8Array header, TwoTuple_usizeTransactionZ[] txdata, number height) {
- bindings.Confirm_transactions_confirmed(this.ptr, header, txdata != null ? Arrays.stream(txdata).map(txdata_conv_28 -> txdata_conv_28 != null ? txdata_conv_28.ptr : 0).toArray(number[]::new) : null, height);
+ bindings.Confirm_transactions_confirmed(this.ptr, InternalUtils.check_arr_len(header, 80), txdata != null ? Arrays.stream(txdata).map(txdata_conv_28 -> txdata_conv_28 != null ? txdata_conv_28.ptr : 0).toArray(number[]::new) : null, height);
}
public void transaction_unconfirmed(Uint8Array txid) {
- bindings.Confirm_transaction_unconfirmed(this.ptr, txid);
+ bindings.Confirm_transaction_unconfirmed(this.ptr, InternalUtils.check_arr_len(txid, 32));
}
public void best_block_updated(Uint8Array header, number height) {
- bindings.Confirm_best_block_updated(this.ptr, header, height);
+ bindings.Confirm_best_block_updated(this.ptr, InternalUtils.check_arr_len(header, 80), height);
}
public Uint8Array[] get_relevant_txids() {
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.CounterpartyChannelTransactionParameters_clone_ptr(this.ptr);
+ return ret;
+ }
+
public CounterpartyChannelTransactionParameters clone() {
number ret = bindings.CounterpartyChannelTransactionParameters_clone(this.ptr);
const ret_hu_conv: CounterpartyChannelTransactionParameters = new CounterpartyChannelTransactionParameters(null, ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.CounterpartyForwardingInfo_clone_ptr(this.ptr);
+ return ret;
+ }
+
public CounterpartyForwardingInfo clone() {
number ret = bindings.CounterpartyForwardingInfo_clone(this.ptr);
const ret_hu_conv: CounterpartyForwardingInfo = new CounterpartyForwardingInfo(null, ret);
Type ret_hu_conv = new Type(null, msg);
ret_hu_conv.ptrs_to.add(this);
Result_NoneLightningErrorZ ret = arg.handle_custom_message(ret_hu_conv, sender_node_id);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
get_and_clear_pending_msg (): number[] {
TwoTuple_PublicKeyTypeZ[] ret = arg.get_and_clear_pending_msg();
- result: number[] = ret != null ? Arrays.stream(ret).map(ret_conv_25 -> ret_conv_25 != null ? ret_conv_25.ptr : 0).toArray(number[]::new) : null;
+ result: number[] = ret != null ? Arrays.stream(ret).map(ret_conv_25 -> ret_conv_25 == null ? 0 : ret_conv_25.clone_ptr()).toArray(number[]::new) : null;
return result;
},
held: CustomMessageHandler;
}
public Result_NoneLightningErrorZ handle_custom_message(Type msg, Uint8Array sender_node_id) {
- number ret = bindings.CustomMessageHandler_handle_custom_message(this.ptr, msg == null ? 0 : msg.ptr, sender_node_id);
+ number ret = bindings.CustomMessageHandler_handle_custom_message(this.ptr, msg == null ? 0 : msg.ptr, InternalUtils.check_arr_len(sender_node_id, 33));
Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
this.ptrs_to.add(msg);
return ret_hu_conv;
// todo: in-line interface filling
read (message_type: number, buffer: Uint8Array): number {
Result_COption_TypeZDecodeErrorZ ret = arg.read(message_type, buffer);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
}
public void set_your_last_per_commitment_secret(Uint8Array val) {
- bindings.DataLossProtect_set_your_last_per_commitment_secret(this.ptr, val);
+ bindings.DataLossProtect_set_your_last_per_commitment_secret(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public Uint8Array get_my_current_per_commitment_point() {
}
public void set_my_current_per_commitment_point(Uint8Array val) {
- bindings.DataLossProtect_set_my_current_per_commitment_point(this.ptr, val);
+ bindings.DataLossProtect_set_my_current_per_commitment_point(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public static DataLossProtect constructor_new(Uint8Array your_last_per_commitment_secret_arg, Uint8Array my_current_per_commitment_point_arg) {
- number ret = bindings.DataLossProtect_new(your_last_per_commitment_secret_arg, my_current_per_commitment_point_arg);
+ number ret = bindings.DataLossProtect_new(InternalUtils.check_arr_len(your_last_per_commitment_secret_arg, 32), InternalUtils.check_arr_len(my_current_per_commitment_point_arg, 33));
const ret_hu_conv: DataLossProtect = new DataLossProtect(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.DataLossProtect_clone_ptr(this.ptr);
+ return ret;
+ }
+
public DataLossProtect clone() {
number ret = bindings.DataLossProtect_clone(this.ptr);
const ret_hu_conv: DataLossProtect = new DataLossProtect(null, ret);
bindings.DecodeError_free(this.ptr);
}
}
+ public number clone_ptr() {
+ number ret = bindings.DecodeError_clone_ptr(this.ptr);
+ return ret;
+ }
+
public DecodeError clone() {
number ret = bindings.DecodeError_clone(this.ptr);
const ret_hu_conv: DecodeError = new DecodeError(null, ret);
}
public void set_per_commitment_point(Uint8Array val) {
- bindings.DelayedPaymentOutputDescriptor_set_per_commitment_point(this.ptr, val);
+ bindings.DelayedPaymentOutputDescriptor_set_per_commitment_point(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public number get_to_self_delay() {
}
public void set_revocation_pubkey(Uint8Array val) {
- bindings.DelayedPaymentOutputDescriptor_set_revocation_pubkey(this.ptr, val);
+ bindings.DelayedPaymentOutputDescriptor_set_revocation_pubkey(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_channel_keys_id() {
}
public void set_channel_keys_id(Uint8Array val) {
- bindings.DelayedPaymentOutputDescriptor_set_channel_keys_id(this.ptr, val);
+ bindings.DelayedPaymentOutputDescriptor_set_channel_keys_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public number get_channel_value_satoshis() {
}
public static DelayedPaymentOutputDescriptor constructor_new(OutPoint outpoint_arg, Uint8Array per_commitment_point_arg, number to_self_delay_arg, TxOut output_arg, Uint8Array revocation_pubkey_arg, Uint8Array channel_keys_id_arg, number channel_value_satoshis_arg) {
- number ret = bindings.DelayedPaymentOutputDescriptor_new(outpoint_arg == null ? 0 : outpoint_arg.ptr & ~1, per_commitment_point_arg, to_self_delay_arg, output_arg.ptr, revocation_pubkey_arg, channel_keys_id_arg, channel_value_satoshis_arg);
+ number ret = bindings.DelayedPaymentOutputDescriptor_new(outpoint_arg == null ? 0 : outpoint_arg.ptr & ~1, InternalUtils.check_arr_len(per_commitment_point_arg, 33), to_self_delay_arg, output_arg.ptr, InternalUtils.check_arr_len(revocation_pubkey_arg, 33), InternalUtils.check_arr_len(channel_keys_id_arg, 32), channel_value_satoshis_arg);
const ret_hu_conv: DelayedPaymentOutputDescriptor = new DelayedPaymentOutputDescriptor(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.DelayedPaymentOutputDescriptor_clone_ptr(this.ptr);
+ return ret;
+ }
+
public DelayedPaymentOutputDescriptor clone() {
number ret = bindings.DelayedPaymentOutputDescriptor_clone(this.ptr);
const ret_hu_conv: DelayedPaymentOutputDescriptor = new DelayedPaymentOutputDescriptor(null, ret);
bindings.Description_free(this.ptr);
}
}
+ public number clone_ptr() {
+ number ret = bindings.Description_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Description clone() {
number ret = bindings.Description_clone(this.ptr);
const ret_hu_conv: Description = new Description(null, ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.DirectionalChannelInfo_clone_ptr(this.ptr);
+ return ret;
+ }
+
public DirectionalChannelInfo clone() {
number ret = bindings.DirectionalChannelInfo_clone(this.ptr);
const ret_hu_conv: DirectionalChannelInfo = new DirectionalChannelInfo(null, ret);
this.msg = msg_hu_conv;
}
}
+ public number clone_ptr() {
+ number ret = bindings.ErrorAction_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ErrorAction clone() {
number ret = bindings.ErrorAction_clone(this.ptr);
ErrorAction ret_hu_conv = ErrorAction.constr_from_ptr(ret);
}
public void set_channel_id(Uint8Array val) {
- bindings.ErrorMessage_set_channel_id(this.ptr, val);
+ bindings.ErrorMessage_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public String get_data() {
}
public static ErrorMessage constructor_new(Uint8Array channel_id_arg, String data_arg) {
- number ret = bindings.ErrorMessage_new(channel_id_arg, data_arg);
+ number ret = bindings.ErrorMessage_new(InternalUtils.check_arr_len(channel_id_arg, 32), data_arg);
const ret_hu_conv: ErrorMessage = new ErrorMessage(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.ErrorMessage_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ErrorMessage clone() {
number ret = bindings.ErrorMessage_clone(this.ptr);
const ret_hu_conv: ErrorMessage = new ErrorMessage(null, ret);
this.transaction = obj.transaction;
}
}
+ public number clone_ptr() {
+ number ret = bindings.Event_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Event clone() {
number ret = bindings.Event_clone(this.ptr);
Event ret_hu_conv = Event.constr_from_ptr(ret);
}
public static Event constructor_funding_generation_ready(Uint8Array temporary_channel_id, number channel_value_satoshis, Uint8Array output_script, number user_channel_id) {
- number ret = bindings.Event_funding_generation_ready(temporary_channel_id, channel_value_satoshis, output_script, user_channel_id);
+ number ret = bindings.Event_funding_generation_ready(InternalUtils.check_arr_len(temporary_channel_id, 32), channel_value_satoshis, output_script, user_channel_id);
Event ret_hu_conv = Event.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static Event constructor_payment_received(Uint8Array payment_hash, number amt, PaymentPurpose purpose) {
- number ret = bindings.Event_payment_received(payment_hash, amt, purpose.ptr);
+ number ret = bindings.Event_payment_received(InternalUtils.check_arr_len(payment_hash, 32), amt, purpose.ptr);
Event ret_hu_conv = Event.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static Event constructor_payment_sent(Uint8Array payment_id, Uint8Array payment_preimage, Uint8Array payment_hash, Option_u64Z fee_paid_msat) {
- number ret = bindings.Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat.ptr);
+ number ret = bindings.Event_payment_sent(InternalUtils.check_arr_len(payment_id, 32), InternalUtils.check_arr_len(payment_preimage, 32), InternalUtils.check_arr_len(payment_hash, 32), fee_paid_msat.ptr);
Event ret_hu_conv = Event.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static Event constructor_payment_path_failed(Uint8Array payment_id, Uint8Array payment_hash, boolean rejected_by_dest, Option_NetworkUpdateZ network_update, boolean all_paths_failed, RouteHop[] path, Option_u64Z short_channel_id, RouteParameters retry) {
- number ret = bindings.Event_payment_path_failed(payment_id, payment_hash, rejected_by_dest, network_update.ptr, all_paths_failed, path != null ? Arrays.stream(path).map(path_conv_10 -> path_conv_10 == null ? 0 : path_conv_10.ptr & ~1).toArray(number[]::new) : null, short_channel_id.ptr, retry == null ? 0 : retry.ptr & ~1);
+ number ret = bindings.Event_payment_path_failed(InternalUtils.check_arr_len(payment_id, 32), InternalUtils.check_arr_len(payment_hash, 32), rejected_by_dest, network_update.ptr, all_paths_failed, path != null ? Arrays.stream(path).map(path_conv_10 -> path_conv_10 == null ? 0 : path_conv_10.ptr & ~1).toArray(number[]::new) : null, short_channel_id.ptr, retry == null ? 0 : retry.ptr & ~1);
Event ret_hu_conv = Event.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static Event constructor_channel_closed(Uint8Array channel_id, number user_channel_id, ClosureReason reason) {
- number ret = bindings.Event_channel_closed(channel_id, user_channel_id, reason.ptr);
+ number ret = bindings.Event_channel_closed(InternalUtils.check_arr_len(channel_id, 32), user_channel_id, reason.ptr);
Event ret_hu_conv = Event.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static Event constructor_discard_funding(Uint8Array channel_id, Uint8Array transaction) {
- number ret = bindings.Event_discard_funding(channel_id, transaction);
+ number ret = bindings.Event_discard_funding(InternalUtils.check_arr_len(channel_id, 32), transaction);
Event ret_hu_conv = Event.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
bindings.ExpiryTime_free(this.ptr);
}
}
+ public number clone_ptr() {
+ number ret = bindings.ExpiryTime_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ExpiryTime clone() {
number ret = bindings.ExpiryTime_clone(this.ptr);
const ret_hu_conv: ExpiryTime = new ExpiryTime(null, ret);
this.script_hash = obj.script_hash;
}
}
+ public number clone_ptr() {
+ number ret = bindings.Fallback_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Fallback clone() {
number ret = bindings.Fallback_clone(this.ptr);
Fallback ret_hu_conv = Fallback.constr_from_ptr(ret);
}
public static Fallback constructor_pub_key_hash(Uint8Array a) {
- number ret = bindings.Fallback_pub_key_hash(a);
+ number ret = bindings.Fallback_pub_key_hash(InternalUtils.check_arr_len(a, 20));
Fallback ret_hu_conv = Fallback.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static Fallback constructor_script_hash(Uint8Array a) {
- number ret = bindings.Fallback_script_hash(a);
+ number ret = bindings.Fallback_script_hash(InternalUtils.check_arr_len(a, 20));
Fallback ret_hu_conv = Fallback.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
const output_hu_conv: WatchedOutput = new WatchedOutput(null, output);
output_hu_conv.ptrs_to.add(this);
Option_C2Tuple_usizeTransactionZZ ret = arg.register_output(output_hu_conv);
- result: number = ret.ptr;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
held: Filter;
}
public void register_tx(Uint8Array txid, Uint8Array script_pubkey) {
- bindings.Filter_register_tx(this.ptr, txid, script_pubkey);
+ bindings.Filter_register_tx(this.ptr, InternalUtils.check_arr_len(txid, 32), script_pubkey);
}
public Option_C2Tuple_usizeTransactionZZ register_output(WatchedOutput output) {
}
public void set_temporary_channel_id(Uint8Array val) {
- bindings.FundingCreated_set_temporary_channel_id(this.ptr, val);
+ bindings.FundingCreated_set_temporary_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public Uint8Array get_funding_txid() {
}
public void set_funding_txid(Uint8Array val) {
- bindings.FundingCreated_set_funding_txid(this.ptr, val);
+ bindings.FundingCreated_set_funding_txid(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public number get_funding_output_index() {
}
public void set_signature(Uint8Array val) {
- bindings.FundingCreated_set_signature(this.ptr, val);
+ bindings.FundingCreated_set_signature(this.ptr, InternalUtils.check_arr_len(val, 64));
}
public static FundingCreated constructor_new(Uint8Array temporary_channel_id_arg, Uint8Array funding_txid_arg, number funding_output_index_arg, Uint8Array signature_arg) {
- number ret = bindings.FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
+ number ret = bindings.FundingCreated_new(InternalUtils.check_arr_len(temporary_channel_id_arg, 32), InternalUtils.check_arr_len(funding_txid_arg, 32), funding_output_index_arg, InternalUtils.check_arr_len(signature_arg, 64));
const ret_hu_conv: FundingCreated = new FundingCreated(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.FundingCreated_clone_ptr(this.ptr);
+ return ret;
+ }
+
public FundingCreated clone() {
number ret = bindings.FundingCreated_clone(this.ptr);
const ret_hu_conv: FundingCreated = new FundingCreated(null, ret);
}
public void set_channel_id(Uint8Array val) {
- bindings.FundingLocked_set_channel_id(this.ptr, val);
+ bindings.FundingLocked_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public Uint8Array get_next_per_commitment_point() {
}
public void set_next_per_commitment_point(Uint8Array val) {
- bindings.FundingLocked_set_next_per_commitment_point(this.ptr, val);
+ bindings.FundingLocked_set_next_per_commitment_point(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public static FundingLocked constructor_new(Uint8Array channel_id_arg, Uint8Array next_per_commitment_point_arg) {
- number ret = bindings.FundingLocked_new(channel_id_arg, next_per_commitment_point_arg);
+ number ret = bindings.FundingLocked_new(InternalUtils.check_arr_len(channel_id_arg, 32), InternalUtils.check_arr_len(next_per_commitment_point_arg, 33));
const ret_hu_conv: FundingLocked = new FundingLocked(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.FundingLocked_clone_ptr(this.ptr);
+ return ret;
+ }
+
public FundingLocked clone() {
number ret = bindings.FundingLocked_clone(this.ptr);
const ret_hu_conv: FundingLocked = new FundingLocked(null, ret);
}
public void set_channel_id(Uint8Array val) {
- bindings.FundingSigned_set_channel_id(this.ptr, val);
+ bindings.FundingSigned_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public Uint8Array get_signature() {
}
public void set_signature(Uint8Array val) {
- bindings.FundingSigned_set_signature(this.ptr, val);
+ bindings.FundingSigned_set_signature(this.ptr, InternalUtils.check_arr_len(val, 64));
}
public static FundingSigned constructor_new(Uint8Array channel_id_arg, Uint8Array signature_arg) {
- number ret = bindings.FundingSigned_new(channel_id_arg, signature_arg);
+ number ret = bindings.FundingSigned_new(InternalUtils.check_arr_len(channel_id_arg, 32), InternalUtils.check_arr_len(signature_arg, 64));
const ret_hu_conv: FundingSigned = new FundingSigned(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.FundingSigned_clone_ptr(this.ptr);
+ return ret;
+ }
+
public FundingSigned clone() {
number ret = bindings.FundingSigned_clone(this.ptr);
const ret_hu_conv: FundingSigned = new FundingSigned(null, ret);
}
public void set_chain_hash(Uint8Array val) {
- bindings.GossipTimestampFilter_set_chain_hash(this.ptr, val);
+ bindings.GossipTimestampFilter_set_chain_hash(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public number get_first_timestamp() {
}
public static GossipTimestampFilter constructor_new(Uint8Array chain_hash_arg, number first_timestamp_arg, number timestamp_range_arg) {
- number ret = bindings.GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
+ number ret = bindings.GossipTimestampFilter_new(InternalUtils.check_arr_len(chain_hash_arg, 32), first_timestamp_arg, timestamp_range_arg);
const ret_hu_conv: GossipTimestampFilter = new GossipTimestampFilter(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.GossipTimestampFilter_clone_ptr(this.ptr);
+ return ret;
+ }
+
public GossipTimestampFilter clone() {
number ret = bindings.GossipTimestampFilter_clone(this.ptr);
const ret_hu_conv: GossipTimestampFilter = new GossipTimestampFilter(null, ret);
}
public void set_payment_hash(Uint8Array val) {
- bindings.HTLCOutputInCommitment_set_payment_hash(this.ptr, val);
+ bindings.HTLCOutputInCommitment_set_payment_hash(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public Option_u32Z get_transaction_output_index() {
}
public static HTLCOutputInCommitment constructor_new(boolean offered_arg, number amount_msat_arg, number cltv_expiry_arg, Uint8Array payment_hash_arg, Option_u32Z transaction_output_index_arg) {
- number ret = bindings.HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg.ptr);
+ number ret = bindings.HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, InternalUtils.check_arr_len(payment_hash_arg, 32), transaction_output_index_arg.ptr);
const ret_hu_conv: HTLCOutputInCommitment = new HTLCOutputInCommitment(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.HTLCOutputInCommitment_clone_ptr(this.ptr);
+ return ret;
+ }
+
public HTLCOutputInCommitment clone() {
number ret = bindings.HTLCOutputInCommitment_clone(this.ptr);
const ret_hu_conv: HTLCOutputInCommitment = new HTLCOutputInCommitment(null, ret);
bindings.HTLCUpdate_free(this.ptr);
}
}
+ public number clone_ptr() {
+ number ret = bindings.HTLCUpdate_clone_ptr(this.ptr);
+ return ret;
+ }
+
public HTLCUpdate clone() {
number ret = bindings.HTLCUpdate_clone(this.ptr);
const ret_hu_conv: HTLCUpdate = new HTLCUpdate(null, ret);
}
public void set_counterparty_sig(Uint8Array val) {
- bindings.HolderCommitmentTransaction_set_counterparty_sig(this.ptr, val);
+ bindings.HolderCommitmentTransaction_set_counterparty_sig(this.ptr, InternalUtils.check_arr_len(val, 64));
}
public void set_counterparty_htlc_sigs(Uint8Array[] val) {
- bindings.HolderCommitmentTransaction_set_counterparty_htlc_sigs(this.ptr, val);
+ bindings.HolderCommitmentTransaction_set_counterparty_htlc_sigs(this.ptr, val != null ? Arrays.stream(val).map(val_conv_12 -> InternalUtils.check_arr_len(val_conv_12, 64)).toArray(Uint8Array[]::new) : null);
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.HolderCommitmentTransaction_clone_ptr(this.ptr);
+ return ret;
}
public HolderCommitmentTransaction clone() {
}
public static HolderCommitmentTransaction constructor_new(CommitmentTransaction commitment_tx, Uint8Array counterparty_sig, Uint8Array[] counterparty_htlc_sigs, Uint8Array holder_funding_key, Uint8Array counterparty_funding_key) {
- number ret = bindings.HolderCommitmentTransaction_new(commitment_tx == null ? 0 : commitment_tx.ptr & ~1, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
+ number ret = bindings.HolderCommitmentTransaction_new(commitment_tx == null ? 0 : commitment_tx.ptr & ~1, InternalUtils.check_arr_len(counterparty_sig, 64), counterparty_htlc_sigs != null ? Arrays.stream(counterparty_htlc_sigs).map(counterparty_htlc_sigs_conv_12 -> InternalUtils.check_arr_len(counterparty_htlc_sigs_conv_12, 64)).toArray(Uint8Array[]::new) : null, InternalUtils.check_arr_len(holder_funding_key, 33), InternalUtils.check_arr_len(counterparty_funding_key, 33));
const ret_hu_conv: HolderCommitmentTransaction = new HolderCommitmentTransaction(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public void set_funding_key(Uint8Array val) {
- bindings.InMemorySigner_set_funding_key(this.ptr, val);
+ bindings.InMemorySigner_set_funding_key(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public Uint8Array get_revocation_base_key() {
}
public void set_revocation_base_key(Uint8Array val) {
- bindings.InMemorySigner_set_revocation_base_key(this.ptr, val);
+ bindings.InMemorySigner_set_revocation_base_key(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public Uint8Array get_payment_key() {
}
public void set_payment_key(Uint8Array val) {
- bindings.InMemorySigner_set_payment_key(this.ptr, val);
+ bindings.InMemorySigner_set_payment_key(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public Uint8Array get_delayed_payment_base_key() {
}
public void set_delayed_payment_base_key(Uint8Array val) {
- bindings.InMemorySigner_set_delayed_payment_base_key(this.ptr, val);
+ bindings.InMemorySigner_set_delayed_payment_base_key(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public Uint8Array get_htlc_base_key() {
}
public void set_htlc_base_key(Uint8Array val) {
- bindings.InMemorySigner_set_htlc_base_key(this.ptr, val);
+ bindings.InMemorySigner_set_htlc_base_key(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public Uint8Array get_commitment_seed() {
}
public void set_commitment_seed(Uint8Array val) {
- bindings.InMemorySigner_set_commitment_seed(this.ptr, val);
+ bindings.InMemorySigner_set_commitment_seed(this.ptr, InternalUtils.check_arr_len(val, 32));
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.InMemorySigner_clone_ptr(this.ptr);
+ return ret;
}
public InMemorySigner clone() {
}
public static InMemorySigner constructor_new(Uint8Array funding_key, Uint8Array revocation_base_key, Uint8Array payment_key, Uint8Array delayed_payment_base_key, Uint8Array htlc_base_key, Uint8Array commitment_seed, number channel_value_satoshis, Uint8Array channel_keys_id) {
- number ret = bindings.InMemorySigner_new(funding_key, revocation_base_key, payment_key, delayed_payment_base_key, htlc_base_key, commitment_seed, channel_value_satoshis, channel_keys_id);
+ number ret = bindings.InMemorySigner_new(InternalUtils.check_arr_len(funding_key, 32), InternalUtils.check_arr_len(revocation_base_key, 32), InternalUtils.check_arr_len(payment_key, 32), InternalUtils.check_arr_len(delayed_payment_base_key, 32), InternalUtils.check_arr_len(htlc_base_key, 32), InternalUtils.check_arr_len(commitment_seed, 32), channel_value_satoshis, InternalUtils.check_arr_len(channel_keys_id, 32));
const ret_hu_conv: InMemorySigner = new InMemorySigner(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.Init_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Init clone() {
number ret = bindings.Init_clone(this.ptr);
const ret_hu_conv: Init = new Init(null, ret);
return ret;
}
+ public number clone_ptr() {
+ number ret = bindings.InitFeatures_clone_ptr(this.ptr);
+ return ret;
+ }
+
public InitFeatures clone() {
number ret = bindings.InitFeatures_clone(this.ptr);
const ret_hu_conv: InitFeatures = new InitFeatures(null, ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.InvalidShutdownScript_clone_ptr(this.ptr);
+ return ret;
+ }
+
public InvalidShutdownScript clone() {
number ret = bindings.InvalidShutdownScript_clone(this.ptr);
const ret_hu_conv: InvalidShutdownScript = new InvalidShutdownScript(null, ret);
return ret;
}
+ public number clone_ptr() {
+ number ret = bindings.Invoice_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Invoice clone() {
number ret = bindings.Invoice_clone(this.ptr);
const ret_hu_conv: Invoice = new Invoice(null, ret);
return ret;
}
+ public number clone_ptr() {
+ number ret = bindings.InvoiceFeatures_clone_ptr(this.ptr);
+ return ret;
+ }
+
public InvoiceFeatures clone() {
number ret = bindings.InvoiceFeatures_clone(this.ptr);
const ret_hu_conv: InvoiceFeatures = new InvoiceFeatures(null, ret);
}
public void remove_cached_payment(Uint8Array payment_hash) {
- bindings.InvoicePayer_remove_cached_payment(this.ptr, payment_hash);
+ bindings.InvoicePayer_remove_cached_payment(this.ptr, InternalUtils.check_arr_len(payment_hash, 32));
}
public EventHandler as_EventHandler() {
bindings.InvoiceSignature_free(this.ptr);
}
}
+ public number clone_ptr() {
+ number ret = bindings.InvoiceSignature_clone_ptr(this.ptr);
+ return ret;
+ }
+
public InvoiceSignature clone() {
number ret = bindings.InvoiceSignature_clone(this.ptr);
const ret_hu_conv: InvoiceSignature = new InvoiceSignature(null, ret);
// todo: in-line interface filling
get_node_secret (): Uint8Array {
Uint8Array ret = arg.get_node_secret();
- return ret;
+ result: Uint8Array = InternalUtils.check_arr_len(ret, 32);
+ return result;
},
get_destination_script (): Uint8Array {
get_shutdown_scriptpubkey (): number {
ShutdownScript ret = arg.get_shutdown_scriptpubkey();
- result: number = ret == null ? 0 : ret.ptr & ~1;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
get_channel_signer (inbound: boolean, channel_value_satoshis: number): number {
Sign ret = arg.get_channel_signer(inbound, channel_value_satoshis);
- result: number = ret == null ? 0 : ret.ptr;
+ result: number = ret == null ? 0 : ret.clone_ptr();
impl_holder.held.ptrs_to.add(ret);
return result;
},
get_secure_random_bytes (): Uint8Array {
Uint8Array ret = arg.get_secure_random_bytes();
- return ret;
+ result: Uint8Array = InternalUtils.check_arr_len(ret, 32);
+ return result;
},
read_chan_signer (reader: Uint8Array): number {
Result_SignDecodeErrorZ ret = arg.read_chan_signer(reader);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
sign_invoice (invoice_preimage: Uint8Array): number {
Result_RecoverableSignatureNoneZ ret = arg.sign_invoice(invoice_preimage);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
}
}
public static KeysManager constructor_new(Uint8Array seed, number starting_time_secs, number starting_time_nanos) {
- number ret = bindings.KeysManager_new(seed, starting_time_secs, starting_time_nanos);
+ number ret = bindings.KeysManager_new(InternalUtils.check_arr_len(seed, 32), starting_time_secs, starting_time_nanos);
const ret_hu_conv: KeysManager = new KeysManager(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public InMemorySigner derive_channel_keys(number channel_value_satoshis, Uint8Array params) {
- number ret = bindings.KeysManager_derive_channel_keys(this.ptr, channel_value_satoshis, params);
+ number ret = bindings.KeysManager_derive_channel_keys(this.ptr, channel_value_satoshis, InternalUtils.check_arr_len(params, 32));
const ret_hu_conv: InMemorySigner = new InMemorySigner(null, ret);
ret_hu_conv.ptrs_to.add(this);
return ret_hu_conv;
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.LightningError_clone_ptr(this.ptr);
+ return ret;
+ }
+
public LightningError clone() {
number ret = bindings.LightningError_clone(this.ptr);
const ret_hu_conv: LightningError = new LightningError(null, ret);
}
public void block_disconnected(Uint8Array header, number height) {
- bindings.Listen_block_disconnected(this.ptr, header, height);
+ bindings.Listen_block_disconnected(this.ptr, InternalUtils.check_arr_len(header, 80), height);
}
}
const impl_holder: LDKLoggerHolder = new LDKLoggerHolder();
let structImplementation = <bindings.LDKLogger>{
// todo: in-line interface filling
- log (record: String): void {
- arg.log(record);
+ log (record: number): void {
+ const record_hu_conv: Record = new Record(null, record);
+ arg.log(record_hu_conv);
},
}
export interface LoggerInterface {
- log(record: String): void;
+ log(record: Record): void;
}
this.msg = msg_hu_conv;
}
}
+ public number clone_ptr() {
+ number ret = bindings.MessageSendEvent_clone_ptr(this.ptr);
+ return ret;
+ }
+
public MessageSendEvent clone() {
number ret = bindings.MessageSendEvent_clone(this.ptr);
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
}
public static MessageSendEvent constructor_send_accept_channel(Uint8Array node_id, AcceptChannel msg) {
- number ret = bindings.MessageSendEvent_send_accept_channel(node_id, msg == null ? 0 : msg.ptr & ~1);
+ number ret = bindings.MessageSendEvent_send_accept_channel(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static MessageSendEvent constructor_send_open_channel(Uint8Array node_id, OpenChannel msg) {
- number ret = bindings.MessageSendEvent_send_open_channel(node_id, msg == null ? 0 : msg.ptr & ~1);
+ number ret = bindings.MessageSendEvent_send_open_channel(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static MessageSendEvent constructor_send_funding_created(Uint8Array node_id, FundingCreated msg) {
- number ret = bindings.MessageSendEvent_send_funding_created(node_id, msg == null ? 0 : msg.ptr & ~1);
+ number ret = bindings.MessageSendEvent_send_funding_created(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static MessageSendEvent constructor_send_funding_signed(Uint8Array node_id, FundingSigned msg) {
- number ret = bindings.MessageSendEvent_send_funding_signed(node_id, msg == null ? 0 : msg.ptr & ~1);
+ number ret = bindings.MessageSendEvent_send_funding_signed(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static MessageSendEvent constructor_send_funding_locked(Uint8Array node_id, FundingLocked msg) {
- number ret = bindings.MessageSendEvent_send_funding_locked(node_id, msg == null ? 0 : msg.ptr & ~1);
+ number ret = bindings.MessageSendEvent_send_funding_locked(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static MessageSendEvent constructor_send_announcement_signatures(Uint8Array node_id, AnnouncementSignatures msg) {
- number ret = bindings.MessageSendEvent_send_announcement_signatures(node_id, msg == null ? 0 : msg.ptr & ~1);
+ number ret = bindings.MessageSendEvent_send_announcement_signatures(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static MessageSendEvent constructor_update_htlcs(Uint8Array node_id, CommitmentUpdate updates) {
- number ret = bindings.MessageSendEvent_update_htlcs(node_id, updates == null ? 0 : updates.ptr & ~1);
+ number ret = bindings.MessageSendEvent_update_htlcs(InternalUtils.check_arr_len(node_id, 33), updates == null ? 0 : updates.ptr & ~1);
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static MessageSendEvent constructor_send_revoke_and_ack(Uint8Array node_id, RevokeAndACK msg) {
- number ret = bindings.MessageSendEvent_send_revoke_and_ack(node_id, msg == null ? 0 : msg.ptr & ~1);
+ number ret = bindings.MessageSendEvent_send_revoke_and_ack(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static MessageSendEvent constructor_send_closing_signed(Uint8Array node_id, ClosingSigned msg) {
- number ret = bindings.MessageSendEvent_send_closing_signed(node_id, msg == null ? 0 : msg.ptr & ~1);
+ number ret = bindings.MessageSendEvent_send_closing_signed(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static MessageSendEvent constructor_send_shutdown(Uint8Array node_id, Shutdown msg) {
- number ret = bindings.MessageSendEvent_send_shutdown(node_id, msg == null ? 0 : msg.ptr & ~1);
+ number ret = bindings.MessageSendEvent_send_shutdown(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static MessageSendEvent constructor_send_channel_reestablish(Uint8Array node_id, ChannelReestablish msg) {
- number ret = bindings.MessageSendEvent_send_channel_reestablish(node_id, msg == null ? 0 : msg.ptr & ~1);
+ number ret = bindings.MessageSendEvent_send_channel_reestablish(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static MessageSendEvent constructor_send_channel_update(Uint8Array node_id, ChannelUpdate msg) {
- number ret = bindings.MessageSendEvent_send_channel_update(node_id, msg == null ? 0 : msg.ptr & ~1);
+ number ret = bindings.MessageSendEvent_send_channel_update(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static MessageSendEvent constructor_handle_error(Uint8Array node_id, ErrorAction action) {
- number ret = bindings.MessageSendEvent_handle_error(node_id, action.ptr);
+ number ret = bindings.MessageSendEvent_handle_error(InternalUtils.check_arr_len(node_id, 33), action.ptr);
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static MessageSendEvent constructor_send_channel_range_query(Uint8Array node_id, QueryChannelRange msg) {
- number ret = bindings.MessageSendEvent_send_channel_range_query(node_id, msg == null ? 0 : msg.ptr & ~1);
+ number ret = bindings.MessageSendEvent_send_channel_range_query(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static MessageSendEvent constructor_send_short_ids_query(Uint8Array node_id, QueryShortChannelIds msg) {
- number ret = bindings.MessageSendEvent_send_short_ids_query(node_id, msg == null ? 0 : msg.ptr & ~1);
+ number ret = bindings.MessageSendEvent_send_short_ids_query(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static MessageSendEvent constructor_send_reply_channel_range(Uint8Array node_id, ReplyChannelRange msg) {
- number ret = bindings.MessageSendEvent_send_reply_channel_range(node_id, msg == null ? 0 : msg.ptr & ~1);
+ number ret = bindings.MessageSendEvent_send_reply_channel_range(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
// todo: in-line interface filling
get_and_clear_pending_msg_events (): number[] {
MessageSendEvent[] ret = arg.get_and_clear_pending_msg_events();
- result: number[] = ret != null ? Arrays.stream(ret).map(ret_conv_18 -> ret_conv_18.ptr).toArray(number[]::new) : null;
+ result: number[] = ret != null ? Arrays.stream(ret).map(ret_conv_18 -> ret_conv_18 == null ? 0 : ret_conv_18.clone_ptr()).toArray(number[]::new) : null;
return result;
},
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.MinFinalCltvExpiry_clone_ptr(this.ptr);
+ return ret;
+ }
+
public MinFinalCltvExpiry clone() {
number ret = bindings.MinFinalCltvExpiry_clone(this.ptr);
const ret_hu_conv: MinFinalCltvExpiry = new MinFinalCltvExpiry(null, ret);
this.update_failed = update_failed_hu_conv;
}
}
+ public number clone_ptr() {
+ number ret = bindings.MonitorEvent_clone_ptr(this.ptr);
+ return ret;
+ }
+
public MonitorEvent clone() {
number ret = bindings.MonitorEvent_clone(this.ptr);
MonitorEvent ret_hu_conv = MonitorEvent.constr_from_ptr(ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.MonitorUpdateError_clone_ptr(this.ptr);
+ return ret;
+ }
+
public MonitorUpdateError clone() {
number ret = bindings.MonitorUpdateError_clone(this.ptr);
const ret_hu_conv: MonitorUpdateError = new MonitorUpdateError(null, ret);
bindings.MonitorUpdateId_free(this.ptr);
}
}
+ public number clone_ptr() {
+ number ret = bindings.MonitorUpdateId_clone_ptr(this.ptr);
+ return ret;
+ }
+
public MonitorUpdateId clone() {
number ret = bindings.MonitorUpdateId_clone(this.ptr);
const ret_hu_conv: MonitorUpdateId = new MonitorUpdateId(null, ret);
this.port = obj.port;
}
}
+ public number clone_ptr() {
+ number ret = bindings.NetAddress_clone_ptr(this.ptr);
+ return ret;
+ }
+
public NetAddress clone() {
number ret = bindings.NetAddress_clone(this.ptr);
NetAddress ret_hu_conv = NetAddress.constr_from_ptr(ret);
}
public static NetAddress constructor_ipv4(Uint8Array addr, number port) {
- number ret = bindings.NetAddress_ipv4(addr, port);
+ number ret = bindings.NetAddress_ipv4(InternalUtils.check_arr_len(addr, 4), port);
NetAddress ret_hu_conv = NetAddress.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static NetAddress constructor_ipv6(Uint8Array addr, number port) {
- number ret = bindings.NetAddress_ipv6(addr, port);
+ number ret = bindings.NetAddress_ipv6(InternalUtils.check_arr_len(addr, 16), port);
NetAddress ret_hu_conv = NetAddress.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static NetAddress constructor_onion_v2(Uint8Array addr, number port) {
- number ret = bindings.NetAddress_onion_v2(addr, port);
+ number ret = bindings.NetAddress_onion_v2(InternalUtils.check_arr_len(addr, 10), port);
NetAddress ret_hu_conv = NetAddress.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static NetAddress constructor_onion_v3(Uint8Array ed25519_pubkey, number checksum, number version, number port) {
- number ret = bindings.NetAddress_onion_v3(ed25519_pubkey, checksum, version, port);
+ number ret = bindings.NetAddress_onion_v3(InternalUtils.check_arr_len(ed25519_pubkey, 32), checksum, version, port);
NetAddress ret_hu_conv = NetAddress.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
const ret_hu_conv: NetGraphMsgHandler = new NetGraphMsgHandler(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
ret_hu_conv.ptrs_to.add(network_graph);
+ ret_hu_conv.ptrs_to.add(chain_access);
ret_hu_conv.ptrs_to.add(logger);
return ret_hu_conv;
}
public void add_chain_access(Option_AccessZ chain_access) {
bindings.NetGraphMsgHandler_add_chain_access(this.ptr, chain_access.ptr);
+ this.ptrs_to.add(chain_access);
}
public RoutingMessageHandler as_RoutingMessageHandler() {
bindings.NetworkGraph_free(this.ptr);
}
}
+ public number clone_ptr() {
+ number ret = bindings.NetworkGraph_clone_ptr(this.ptr);
+ return ret;
+ }
+
public NetworkGraph clone() {
number ret = bindings.NetworkGraph_clone(this.ptr);
const ret_hu_conv: NetworkGraph = new NetworkGraph(null, ret);
}
public static NetworkGraph constructor_new(Uint8Array genesis_hash) {
- number ret = bindings.NetworkGraph_new(genesis_hash);
+ number ret = bindings.NetworkGraph_new(InternalUtils.check_arr_len(genesis_hash, 32));
const ret_hu_conv: NetworkGraph = new NetworkGraph(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
number ret = bindings.NetworkGraph_update_channel_from_announcement(this.ptr, msg == null ? 0 : msg.ptr & ~1, chain_access.ptr);
Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
this.ptrs_to.add(msg);
+ this.ptrs_to.add(chain_access);
return ret_hu_conv;
}
number ret = bindings.NetworkGraph_update_channel_from_unsigned_announcement(this.ptr, msg == null ? 0 : msg.ptr & ~1, chain_access.ptr);
Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
this.ptrs_to.add(msg);
+ this.ptrs_to.add(chain_access);
return ret_hu_conv;
}
}
public void fail_node(Uint8Array _node_id, boolean is_permanent) {
- bindings.NetworkGraph_fail_node(this.ptr, _node_id, is_permanent);
+ bindings.NetworkGraph_fail_node(this.ptr, InternalUtils.check_arr_len(_node_id, 33), is_permanent);
}
public Result_NoneLightningErrorZ update_channel(ChannelUpdate msg) {
this.is_permanent = obj.is_permanent;
}
}
+ public number clone_ptr() {
+ number ret = bindings.NetworkUpdate_clone_ptr(this.ptr);
+ return ret;
+ }
+
public NetworkUpdate clone() {
number ret = bindings.NetworkUpdate_clone(this.ptr);
NetworkUpdate ret_hu_conv = NetworkUpdate.constr_from_ptr(ret);
}
public static NetworkUpdate constructor_node_failure(Uint8Array node_id, boolean is_permanent) {
- number ret = bindings.NetworkUpdate_node_failure(node_id, is_permanent);
+ number ret = bindings.NetworkUpdate_node_failure(InternalUtils.check_arr_len(node_id, 33), is_permanent);
NetworkUpdate ret_hu_conv = NetworkUpdate.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public void set_signature(Uint8Array val) {
- bindings.NodeAnnouncement_set_signature(this.ptr, val);
+ bindings.NodeAnnouncement_set_signature(this.ptr, InternalUtils.check_arr_len(val, 64));
}
public UnsignedNodeAnnouncement get_contents() {
}
public static NodeAnnouncement constructor_new(Uint8Array signature_arg, UnsignedNodeAnnouncement contents_arg) {
- number ret = bindings.NodeAnnouncement_new(signature_arg, contents_arg == null ? 0 : contents_arg.ptr & ~1);
+ number ret = bindings.NodeAnnouncement_new(InternalUtils.check_arr_len(signature_arg, 64), contents_arg == null ? 0 : contents_arg.ptr & ~1);
const ret_hu_conv: NodeAnnouncement = new NodeAnnouncement(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.NodeAnnouncement_clone_ptr(this.ptr);
+ return ret;
+ }
+
public NodeAnnouncement clone() {
number ret = bindings.NodeAnnouncement_clone(this.ptr);
const ret_hu_conv: NodeAnnouncement = new NodeAnnouncement(null, ret);
}
public void set_rgb(Uint8Array val) {
- bindings.NodeAnnouncementInfo_set_rgb(this.ptr, val);
+ bindings.NodeAnnouncementInfo_set_rgb(this.ptr, InternalUtils.check_arr_len(val, 3));
}
public Uint8Array get_alias() {
}
public void set_alias(Uint8Array val) {
- bindings.NodeAnnouncementInfo_set_alias(this.ptr, val);
+ bindings.NodeAnnouncementInfo_set_alias(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public void set_addresses(NetAddress[] val) {
}
public static NodeAnnouncementInfo constructor_new(NodeFeatures features_arg, number last_update_arg, Uint8Array rgb_arg, Uint8Array alias_arg, NetAddress[] addresses_arg, NodeAnnouncement announcement_message_arg) {
- number ret = bindings.NodeAnnouncementInfo_new(features_arg == null ? 0 : features_arg.ptr & ~1, last_update_arg, rgb_arg, alias_arg, addresses_arg != null ? Arrays.stream(addresses_arg).map(addresses_arg_conv_12 -> addresses_arg_conv_12.ptr).toArray(number[]::new) : null, announcement_message_arg == null ? 0 : announcement_message_arg.ptr & ~1);
+ number ret = bindings.NodeAnnouncementInfo_new(features_arg == null ? 0 : features_arg.ptr & ~1, last_update_arg, InternalUtils.check_arr_len(rgb_arg, 3), InternalUtils.check_arr_len(alias_arg, 32), addresses_arg != null ? Arrays.stream(addresses_arg).map(addresses_arg_conv_12 -> addresses_arg_conv_12.ptr).toArray(number[]::new) : null, announcement_message_arg == null ? 0 : announcement_message_arg.ptr & ~1);
const ret_hu_conv: NodeAnnouncementInfo = new NodeAnnouncementInfo(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.NodeAnnouncementInfo_clone_ptr(this.ptr);
+ return ret;
+ }
+
public NodeAnnouncementInfo clone() {
number ret = bindings.NodeAnnouncementInfo_clone(this.ptr);
const ret_hu_conv: NodeAnnouncementInfo = new NodeAnnouncementInfo(null, ret);
return ret;
}
+ public number clone_ptr() {
+ number ret = bindings.NodeFeatures_clone_ptr(this.ptr);
+ return ret;
+ }
+
public NodeFeatures clone() {
number ret = bindings.NodeFeatures_clone(this.ptr);
const ret_hu_conv: NodeFeatures = new NodeFeatures(null, ret);
bindings.NodeId_free(this.ptr);
}
}
+ public number clone_ptr() {
+ number ret = bindings.NodeId_clone_ptr(this.ptr);
+ return ret;
+ }
+
public NodeId clone() {
number ret = bindings.NodeId_clone(this.ptr);
const ret_hu_conv: NodeId = new NodeId(null, ret);
}
public static NodeId constructor_from_pubkey(Uint8Array pubkey) {
- number ret = bindings.NodeId_from_pubkey(pubkey);
+ number ret = bindings.NodeId_from_pubkey(InternalUtils.check_arr_len(pubkey, 33));
const ret_hu_conv: NodeId = new NodeId(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.NodeInfo_clone_ptr(this.ptr);
+ return ret;
+ }
+
public NodeInfo clone() {
number ret = bindings.NodeInfo_clone(this.ptr);
const ret_hu_conv: NodeInfo = new NodeInfo(null, ret);
}
public void set_chain_hash(Uint8Array val) {
- bindings.OpenChannel_set_chain_hash(this.ptr, val);
+ bindings.OpenChannel_set_chain_hash(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public Uint8Array get_temporary_channel_id() {
}
public void set_temporary_channel_id(Uint8Array val) {
- bindings.OpenChannel_set_temporary_channel_id(this.ptr, val);
+ bindings.OpenChannel_set_temporary_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public number get_funding_satoshis() {
}
public void set_funding_pubkey(Uint8Array val) {
- bindings.OpenChannel_set_funding_pubkey(this.ptr, val);
+ bindings.OpenChannel_set_funding_pubkey(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_revocation_basepoint() {
}
public void set_revocation_basepoint(Uint8Array val) {
- bindings.OpenChannel_set_revocation_basepoint(this.ptr, val);
+ bindings.OpenChannel_set_revocation_basepoint(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_payment_point() {
}
public void set_payment_point(Uint8Array val) {
- bindings.OpenChannel_set_payment_point(this.ptr, val);
+ bindings.OpenChannel_set_payment_point(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_delayed_payment_basepoint() {
}
public void set_delayed_payment_basepoint(Uint8Array val) {
- bindings.OpenChannel_set_delayed_payment_basepoint(this.ptr, val);
+ bindings.OpenChannel_set_delayed_payment_basepoint(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_htlc_basepoint() {
}
public void set_htlc_basepoint(Uint8Array val) {
- bindings.OpenChannel_set_htlc_basepoint(this.ptr, val);
+ bindings.OpenChannel_set_htlc_basepoint(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_first_per_commitment_point() {
}
public void set_first_per_commitment_point(Uint8Array val) {
- bindings.OpenChannel_set_first_per_commitment_point(this.ptr, val);
+ bindings.OpenChannel_set_first_per_commitment_point(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public number get_channel_flags() {
bindings.OpenChannel_set_channel_flags(this.ptr, val);
}
+ public number clone_ptr() {
+ number ret = bindings.OpenChannel_clone_ptr(this.ptr);
+ return ret;
+ }
+
public OpenChannel clone() {
number ret = bindings.OpenChannel_clone(this.ptr);
const ret_hu_conv: OpenChannel = new OpenChannel(null, ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.COption_C2Tuple_usizeTransactionZZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Option_C2Tuple_usizeTransactionZZ clone() {
number ret = bindings.COption_C2Tuple_usizeTransactionZZ_clone(this.ptr);
Option_C2Tuple_usizeTransactionZZ ret_hu_conv = Option_C2Tuple_usizeTransactionZZ.constr_from_ptr(ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.COption_CVec_NetAddressZZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Option_CVec_NetAddressZZ clone() {
number ret = bindings.COption_CVec_NetAddressZZ_clone(this.ptr);
Option_CVec_NetAddressZZ ret_hu_conv = Option_CVec_NetAddressZZ.constr_from_ptr(ret);
--- /dev/null
+
+import CommonBase from './CommonBase';
+import * as bindings from '../bindings' // TODO: figure out location
+
+export default class COption_ClosureReasonZ extends CommonBase {
+ protected constructor(_dummy: object, ptr: number) { super(ptr); }
+ protected finalize() {
+ super.finalize();
+ if (this.ptr != 0) { bindings.COption_ClosureReasonZ_free(this.ptr); }
+ }
+ static constr_from_ptr(ptr: number): COption_ClosureReasonZ {
+ const raw_val: bindings.LDKCOption_ClosureReasonZ = bindings.LDKCOption_ClosureReasonZ_ref_from_ptr(ptr);
+ if (raw_val instanceof bindings.LDKCOption_ClosureReasonZ.Some) {
+ return new Some(this.ptr, raw_val);
+ }
+ if (raw_val instanceof bindings.LDKCOption_ClosureReasonZ.None) {
+ return new None(this.ptr, raw_val);
+ }
+ throw new Error('oops, this should be unreachable'); // Unreachable without extending the (internal) bindings interface
+ }
+
+}
+export class Some extends COption_ClosureReasonZ {
+ public some: ClosureReason;
+ private constructor(ptr: number, obj: bindings.LDKCOption_ClosureReasonZ.Some) {
+ super(null, ptr);
+ const some: number = obj.some;
+ ClosureReason some_hu_conv = ClosureReason.constr_from_ptr(some);
+ some_hu_conv.ptrs_to.add(this);
+ this.some = some_hu_conv;
+ }
+}
+export class None extends COption_ClosureReasonZ {
+ private constructor(ptr: number, obj: bindings.LDKCOption_ClosureReasonZ.None) {
+ super(null, ptr);
+ }
+}
+ public static Option_ClosureReasonZ constructor_some(ClosureReason o) {
+ number ret = bindings.COption_ClosureReasonZ_some(o.ptr);
+ Option_ClosureReasonZ ret_hu_conv = Option_ClosureReasonZ.constr_from_ptr(ret);
+ ret_hu_conv.ptrs_to.add(ret_hu_conv);
+ return ret_hu_conv;
+ }
+
+ public static Option_ClosureReasonZ constructor_none() {
+ number ret = bindings.COption_ClosureReasonZ_none();
+ Option_ClosureReasonZ ret_hu_conv = Option_ClosureReasonZ.constr_from_ptr(ret);
+ ret_hu_conv.ptrs_to.add(ret_hu_conv);
+ return ret_hu_conv;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.COption_ClosureReasonZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
+ public Option_ClosureReasonZ clone() {
+ number ret = bindings.COption_ClosureReasonZ_clone(this.ptr);
+ Option_ClosureReasonZ ret_hu_conv = Option_ClosureReasonZ.constr_from_ptr(ret);
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+}
--- /dev/null
+
+import CommonBase from './CommonBase';
+import * as bindings from '../bindings' // TODO: figure out location
+
+export default class COption_EventZ extends CommonBase {
+ protected constructor(_dummy: object, ptr: number) { super(ptr); }
+ protected finalize() {
+ super.finalize();
+ if (this.ptr != 0) { bindings.COption_EventZ_free(this.ptr); }
+ }
+ static constr_from_ptr(ptr: number): COption_EventZ {
+ const raw_val: bindings.LDKCOption_EventZ = bindings.LDKCOption_EventZ_ref_from_ptr(ptr);
+ if (raw_val instanceof bindings.LDKCOption_EventZ.Some) {
+ return new Some(this.ptr, raw_val);
+ }
+ if (raw_val instanceof bindings.LDKCOption_EventZ.None) {
+ return new None(this.ptr, raw_val);
+ }
+ throw new Error('oops, this should be unreachable'); // Unreachable without extending the (internal) bindings interface
+ }
+
+}
+export class Some extends COption_EventZ {
+ public some: Event;
+ private constructor(ptr: number, obj: bindings.LDKCOption_EventZ.Some) {
+ super(null, ptr);
+ const some: number = obj.some;
+ Event some_hu_conv = Event.constr_from_ptr(some);
+ some_hu_conv.ptrs_to.add(this);
+ this.some = some_hu_conv;
+ }
+}
+export class None extends COption_EventZ {
+ private constructor(ptr: number, obj: bindings.LDKCOption_EventZ.None) {
+ super(null, ptr);
+ }
+}
+ public static Option_EventZ constructor_some(Event o) {
+ number ret = bindings.COption_EventZ_some(o.ptr);
+ Option_EventZ ret_hu_conv = Option_EventZ.constr_from_ptr(ret);
+ ret_hu_conv.ptrs_to.add(ret_hu_conv);
+ return ret_hu_conv;
+ }
+
+ public static Option_EventZ constructor_none() {
+ number ret = bindings.COption_EventZ_none();
+ Option_EventZ ret_hu_conv = Option_EventZ.constr_from_ptr(ret);
+ ret_hu_conv.ptrs_to.add(ret_hu_conv);
+ return ret_hu_conv;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.COption_EventZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
+ public Option_EventZ clone() {
+ number ret = bindings.COption_EventZ_clone(this.ptr);
+ Option_EventZ ret_hu_conv = Option_EventZ.constr_from_ptr(ret);
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+}
--- /dev/null
+
+import CommonBase from './CommonBase';
+import * as bindings from '../bindings' // TODO: figure out location
+
+export default class COption_MonitorEventZ extends CommonBase {
+ protected constructor(_dummy: object, ptr: number) { super(ptr); }
+ protected finalize() {
+ super.finalize();
+ if (this.ptr != 0) { bindings.COption_MonitorEventZ_free(this.ptr); }
+ }
+ static constr_from_ptr(ptr: number): COption_MonitorEventZ {
+ const raw_val: bindings.LDKCOption_MonitorEventZ = bindings.LDKCOption_MonitorEventZ_ref_from_ptr(ptr);
+ if (raw_val instanceof bindings.LDKCOption_MonitorEventZ.Some) {
+ return new Some(this.ptr, raw_val);
+ }
+ if (raw_val instanceof bindings.LDKCOption_MonitorEventZ.None) {
+ return new None(this.ptr, raw_val);
+ }
+ throw new Error('oops, this should be unreachable'); // Unreachable without extending the (internal) bindings interface
+ }
+
+}
+export class Some extends COption_MonitorEventZ {
+ public some: MonitorEvent;
+ private constructor(ptr: number, obj: bindings.LDKCOption_MonitorEventZ.Some) {
+ super(null, ptr);
+ const some: number = obj.some;
+ MonitorEvent some_hu_conv = MonitorEvent.constr_from_ptr(some);
+ some_hu_conv.ptrs_to.add(this);
+ this.some = some_hu_conv;
+ }
+}
+export class None extends COption_MonitorEventZ {
+ private constructor(ptr: number, obj: bindings.LDKCOption_MonitorEventZ.None) {
+ super(null, ptr);
+ }
+}
+ public static Option_MonitorEventZ constructor_some(MonitorEvent o) {
+ number ret = bindings.COption_MonitorEventZ_some(o.ptr);
+ Option_MonitorEventZ ret_hu_conv = Option_MonitorEventZ.constr_from_ptr(ret);
+ ret_hu_conv.ptrs_to.add(ret_hu_conv);
+ return ret_hu_conv;
+ }
+
+ public static Option_MonitorEventZ constructor_none() {
+ number ret = bindings.COption_MonitorEventZ_none();
+ Option_MonitorEventZ ret_hu_conv = Option_MonitorEventZ.constr_from_ptr(ret);
+ ret_hu_conv.ptrs_to.add(ret_hu_conv);
+ return ret_hu_conv;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.COption_MonitorEventZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
+ public Option_MonitorEventZ clone() {
+ number ret = bindings.COption_MonitorEventZ_clone(this.ptr);
+ Option_MonitorEventZ ret_hu_conv = Option_MonitorEventZ.constr_from_ptr(ret);
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+}
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.COption_NetworkUpdateZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Option_NetworkUpdateZ clone() {
number ret = bindings.COption_NetworkUpdateZ_clone(this.ptr);
Option_NetworkUpdateZ ret_hu_conv = Option_NetworkUpdateZ.constr_from_ptr(ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.COption_TypeZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Option_TypeZ clone() {
number ret = bindings.COption_TypeZ_clone(this.ptr);
Option_TypeZ ret_hu_conv = Option_TypeZ.constr_from_ptr(ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.COption_u16Z_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Option_u16Z clone() {
number ret = bindings.COption_u16Z_clone(this.ptr);
Option_u16Z ret_hu_conv = Option_u16Z.constr_from_ptr(ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.COption_u32Z_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Option_u32Z clone() {
number ret = bindings.COption_u32Z_clone(this.ptr);
Option_u32Z ret_hu_conv = Option_u32Z.constr_from_ptr(ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.COption_u64Z_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Option_u64Z clone() {
number ret = bindings.COption_u64Z_clone(this.ptr);
Option_u64Z ret_hu_conv = Option_u64Z.constr_from_ptr(ret);
}
public void set_txid(Uint8Array val) {
- bindings.OutPoint_set_txid(this.ptr, val);
+ bindings.OutPoint_set_txid(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public number get_index() {
}
public static OutPoint constructor_new(Uint8Array txid_arg, number index_arg) {
- number ret = bindings.OutPoint_new(txid_arg, index_arg);
+ number ret = bindings.OutPoint_new(InternalUtils.check_arr_len(txid_arg, 32), index_arg);
const ret_hu_conv: OutPoint = new OutPoint(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.OutPoint_clone_ptr(this.ptr);
+ return ret;
+ }
+
public OutPoint clone() {
number ret = bindings.OutPoint_clone(this.ptr);
const ret_hu_conv: OutPoint = new OutPoint(null, ret);
}
public void set_pubkey(Uint8Array val) {
- bindings.Payee_set_pubkey(this.ptr, val);
+ bindings.Payee_set_pubkey(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public InvoiceFeatures get_features() {
}
public static Payee constructor_new(Uint8Array pubkey_arg, InvoiceFeatures features_arg, RouteHint[] route_hints_arg, Option_u64Z expiry_time_arg) {
- number ret = bindings.Payee_new(pubkey_arg, features_arg == null ? 0 : features_arg.ptr & ~1, route_hints_arg != null ? Arrays.stream(route_hints_arg).map(route_hints_arg_conv_11 -> route_hints_arg_conv_11 == null ? 0 : route_hints_arg_conv_11.ptr & ~1).toArray(number[]::new) : null, expiry_time_arg.ptr);
+ number ret = bindings.Payee_new(InternalUtils.check_arr_len(pubkey_arg, 33), features_arg == null ? 0 : features_arg.ptr & ~1, route_hints_arg != null ? Arrays.stream(route_hints_arg).map(route_hints_arg_conv_11 -> route_hints_arg_conv_11 == null ? 0 : route_hints_arg_conv_11.ptr & ~1).toArray(number[]::new) : null, expiry_time_arg.ptr);
const ret_hu_conv: Payee = new Payee(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.Payee_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Payee clone() {
number ret = bindings.Payee_clone(this.ptr);
const ret_hu_conv: Payee = new Payee(null, ret);
}
public static Payee constructor_from_node_id(Uint8Array pubkey) {
- number ret = bindings.Payee_from_node_id(pubkey);
+ number ret = bindings.Payee_from_node_id(InternalUtils.check_arr_len(pubkey, 33));
const ret_hu_conv: Payee = new Payee(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static Payee constructor_for_keysend(Uint8Array pubkey) {
- number ret = bindings.Payee_for_keysend(pubkey);
+ number ret = bindings.Payee_for_keysend(InternalUtils.check_arr_len(pubkey, 33));
const ret_hu_conv: Payee = new Payee(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public void set_a(Uint8Array val) {
- bindings.PayeePubKey_set_a(this.ptr, val);
+ bindings.PayeePubKey_set_a(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public static PayeePubKey constructor_new(Uint8Array a_arg) {
- number ret = bindings.PayeePubKey_new(a_arg);
+ number ret = bindings.PayeePubKey_new(InternalUtils.check_arr_len(a_arg, 33));
const ret_hu_conv: PayeePubKey = new PayeePubKey(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.PayeePubKey_clone_ptr(this.ptr);
+ return ret;
+ }
+
public PayeePubKey clone() {
number ret = bindings.PayeePubKey_clone(this.ptr);
const ret_hu_conv: PayeePubKey = new PayeePubKey(null, ret);
// todo: in-line interface filling
node_id (): Uint8Array {
Uint8Array ret = arg.node_id();
- return ret;
+ result: Uint8Array = InternalUtils.check_arr_len(ret, 33);
+ return result;
},
first_hops (): number[] {
ChannelDetails[] ret = arg.first_hops();
- result: number[] = ret != null ? Arrays.stream(ret).map(ret_conv_16 -> ret_conv_16 == null ? 0 : ret_conv_16.ptr & ~1).toArray(number[]::new) : null;
+ result: number[] = ret != null ? Arrays.stream(ret).map(ret_conv_16 -> ret_conv_16 == null ? 0 : ret_conv_16.clone_ptr()).toArray(number[]::new) : null;
return result;
},
send_payment (route: number, payment_hash: Uint8Array, payment_secret: Uint8Array): number {
const route_hu_conv: Route = new Route(null, route);
Result_PaymentIdPaymentSendFailureZ ret = arg.send_payment(route_hu_conv, payment_hash, payment_secret);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
retry_payment (route: number, payment_id: Uint8Array): number {
const route_hu_conv: Route = new Route(null, route);
Result_NonePaymentSendFailureZ ret = arg.retry_payment(route_hu_conv, payment_id);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
}
public Result_PaymentIdPaymentSendFailureZ send_payment(Route route, Uint8Array payment_hash, Uint8Array payment_secret) {
- number ret = bindings.Payer_send_payment(this.ptr, route == null ? 0 : route.ptr & ~1, payment_hash, payment_secret);
+ number ret = bindings.Payer_send_payment(this.ptr, route == null ? 0 : route.ptr & ~1, InternalUtils.check_arr_len(payment_hash, 32), InternalUtils.check_arr_len(payment_secret, 32));
Result_PaymentIdPaymentSendFailureZ ret_hu_conv = Result_PaymentIdPaymentSendFailureZ.constr_from_ptr(ret);
this.ptrs_to.add(route);
return ret_hu_conv;
}
public Result_NonePaymentSendFailureZ retry_payment(Route route, Uint8Array payment_id) {
- number ret = bindings.Payer_retry_payment(this.ptr, route == null ? 0 : route.ptr & ~1, payment_id);
+ number ret = bindings.Payer_retry_payment(this.ptr, route == null ? 0 : route.ptr & ~1, InternalUtils.check_arr_len(payment_id, 32));
Result_NonePaymentSendFailureZ ret_hu_conv = Result_NonePaymentSendFailureZ.constr_from_ptr(ret);
this.ptrs_to.add(route);
return ret_hu_conv;
this.sending = sending_hu_conv;
}
}
+ public number clone_ptr() {
+ number ret = bindings.PaymentError_clone_ptr(this.ptr);
+ return ret;
+ }
+
public PaymentError clone() {
number ret = bindings.PaymentError_clone(this.ptr);
PaymentError ret_hu_conv = PaymentError.constr_from_ptr(ret);
this.spontaneous_payment = obj.spontaneous_payment;
}
}
+ public number clone_ptr() {
+ number ret = bindings.PaymentPurpose_clone_ptr(this.ptr);
+ return ret;
+ }
+
public PaymentPurpose clone() {
number ret = bindings.PaymentPurpose_clone(this.ptr);
PaymentPurpose ret_hu_conv = PaymentPurpose.constr_from_ptr(ret);
}
public static PaymentPurpose constructor_invoice_payment(Uint8Array payment_preimage, Uint8Array payment_secret, number user_payment_id) {
- number ret = bindings.PaymentPurpose_invoice_payment(payment_preimage, payment_secret, user_payment_id);
+ number ret = bindings.PaymentPurpose_invoice_payment(InternalUtils.check_arr_len(payment_preimage, 32), InternalUtils.check_arr_len(payment_secret, 32), user_payment_id);
PaymentPurpose ret_hu_conv = PaymentPurpose.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static PaymentPurpose constructor_spontaneous_payment(Uint8Array a) {
- number ret = bindings.PaymentPurpose_spontaneous_payment(a);
+ number ret = bindings.PaymentPurpose_spontaneous_payment(InternalUtils.check_arr_len(a, 32));
PaymentPurpose ret_hu_conv = PaymentPurpose.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
this.payment_id = obj.payment_id;
}
}
+ public number clone_ptr() {
+ number ret = bindings.PaymentSendFailure_clone_ptr(this.ptr);
+ return ret;
+ }
+
public PaymentSendFailure clone() {
number ret = bindings.PaymentSendFailure_clone(this.ptr);
PaymentSendFailure ret_hu_conv = PaymentSendFailure.constr_from_ptr(ret);
}
public static PaymentSendFailure constructor_partial_failure(Result_NoneAPIErrorZ[] results, RouteParameters failed_paths_retry, Uint8Array payment_id) {
- number ret = bindings.PaymentSendFailure_partial_failure(results != null ? Arrays.stream(results).map(results_conv_22 -> results_conv_22 != null ? results_conv_22.ptr : 0).toArray(number[]::new) : null, failed_paths_retry == null ? 0 : failed_paths_retry.ptr & ~1, payment_id);
+ number ret = bindings.PaymentSendFailure_partial_failure(results != null ? Arrays.stream(results).map(results_conv_22 -> results_conv_22 != null ? results_conv_22.ptr : 0).toArray(number[]::new) : null, failed_paths_retry == null ? 0 : failed_paths_retry.ptr & ~1, InternalUtils.check_arr_len(payment_id, 32));
PaymentSendFailure ret_hu_conv = PaymentSendFailure.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.PeerHandleError_clone_ptr(this.ptr);
+ return ret;
+ }
+
public PeerHandleError clone() {
number ret = bindings.PeerHandleError_clone(this.ptr);
const ret_hu_conv: PeerHandleError = new PeerHandleError(null, ret);
}
}
public static PeerManager constructor_new(ChannelMessageHandler message_handler_chan_handler_arg, RoutingMessageHandler message_handler_route_handler_arg, Uint8Array our_node_secret, Uint8Array ephemeral_random_data, Logger logger, CustomMessageHandler custom_message_handler) {
- number ret = bindings.PeerManager_new(bindings.MessageHandler_new(message_handler_chan_handler_arg == null ? 0 : message_handler_chan_handler_arg.ptr, message_handler_route_handler_arg == null ? 0 : message_handler_route_handler_arg.ptr), our_node_secret, ephemeral_random_data, logger == null ? 0 : logger.ptr, custom_message_handler == null ? 0 : custom_message_handler.ptr);
+ number ret = bindings.PeerManager_new(bindings.MessageHandler_new(message_handler_chan_handler_arg == null ? 0 : message_handler_chan_handler_arg.ptr, message_handler_route_handler_arg == null ? 0 : message_handler_route_handler_arg.ptr), InternalUtils.check_arr_len(our_node_secret, 32), InternalUtils.check_arr_len(ephemeral_random_data, 32), logger == null ? 0 : logger.ptr, custom_message_handler == null ? 0 : custom_message_handler.ptr);
const ret_hu_conv: PeerManager = new PeerManager(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
ret_hu_conv.ptrs_to.add(message_handler_chan_handler_arg);
}
public Result_CVec_u8ZPeerHandleErrorZ new_outbound_connection(Uint8Array their_node_id, SocketDescriptor descriptor) {
- number ret = bindings.PeerManager_new_outbound_connection(this.ptr, their_node_id, descriptor == null ? 0 : descriptor.ptr);
+ number ret = bindings.PeerManager_new_outbound_connection(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), descriptor == null ? 0 : descriptor.ptr);
Result_CVec_u8ZPeerHandleErrorZ ret_hu_conv = Result_CVec_u8ZPeerHandleErrorZ.constr_from_ptr(ret);
this.ptrs_to.add(descriptor);
return ret_hu_conv;
}
public void disconnect_by_node_id(Uint8Array node_id, boolean no_connection_possible) {
- bindings.PeerManager_disconnect_by_node_id(this.ptr, node_id, no_connection_possible);
+ bindings.PeerManager_disconnect_by_node_id(this.ptr, InternalUtils.check_arr_len(node_id, 33), no_connection_possible);
}
public void disconnect_all_peers() {
const update_id_hu_conv: MonitorUpdateId = new MonitorUpdateId(null, update_id);
update_id_hu_conv.ptrs_to.add(this);
Result_NoneChannelMonitorUpdateErrZ ret = arg.persist_new_channel(channel_id_hu_conv, data_hu_conv, update_id_hu_conv);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
const update_id_hu_conv: MonitorUpdateId = new MonitorUpdateId(null, update_id);
update_id_hu_conv.ptrs_to.add(this);
Result_NoneChannelMonitorUpdateErrZ ret = arg.update_persisted_channel(channel_id_hu_conv, update_hu_conv, data_hu_conv, update_id_hu_conv);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.Ping_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Ping clone() {
number ret = bindings.Ping_clone(this.ptr);
const ret_hu_conv: Ping = new Ping(null, ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.Pong_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Pong clone() {
number ret = bindings.Pong_clone(this.ptr);
const ret_hu_conv: Pong = new Pong(null, ret);
return ret;
}
+ public number clone_ptr() {
+ number ret = bindings.PositiveTimestamp_clone_ptr(this.ptr);
+ return ret;
+ }
+
public PositiveTimestamp clone() {
number ret = bindings.PositiveTimestamp_clone(this.ptr);
const ret_hu_conv: PositiveTimestamp = new PositiveTimestamp(null, ret);
bindings.PrivateRoute_free(this.ptr);
}
}
+ public number clone_ptr() {
+ number ret = bindings.PrivateRoute_clone_ptr(this.ptr);
+ return ret;
+ }
+
public PrivateRoute clone() {
number ret = bindings.PrivateRoute_clone(this.ptr);
const ret_hu_conv: PrivateRoute = new PrivateRoute(null, ret);
}
public void set_chain_hash(Uint8Array val) {
- bindings.QueryChannelRange_set_chain_hash(this.ptr, val);
+ bindings.QueryChannelRange_set_chain_hash(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public number get_first_blocknum() {
}
public static QueryChannelRange constructor_new(Uint8Array chain_hash_arg, number first_blocknum_arg, number number_of_blocks_arg) {
- number ret = bindings.QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
+ number ret = bindings.QueryChannelRange_new(InternalUtils.check_arr_len(chain_hash_arg, 32), first_blocknum_arg, number_of_blocks_arg);
const ret_hu_conv: QueryChannelRange = new QueryChannelRange(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.QueryChannelRange_clone_ptr(this.ptr);
+ return ret;
+ }
+
public QueryChannelRange clone() {
number ret = bindings.QueryChannelRange_clone(this.ptr);
const ret_hu_conv: QueryChannelRange = new QueryChannelRange(null, ret);
}
public void set_chain_hash(Uint8Array val) {
- bindings.QueryShortChannelIds_set_chain_hash(this.ptr, val);
+ bindings.QueryShortChannelIds_set_chain_hash(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public void set_short_channel_ids(number[] val) {
}
public static QueryShortChannelIds constructor_new(Uint8Array chain_hash_arg, number[] short_channel_ids_arg) {
- number ret = bindings.QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
+ number ret = bindings.QueryShortChannelIds_new(InternalUtils.check_arr_len(chain_hash_arg, 32), short_channel_ids_arg);
const ret_hu_conv: QueryShortChannelIds = new QueryShortChannelIds(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.QueryShortChannelIds_clone_ptr(this.ptr);
+ return ret;
+ }
+
public QueryShortChannelIds clone() {
number ret = bindings.QueryShortChannelIds_clone(this.ptr);
const ret_hu_conv: QueryShortChannelIds = new QueryShortChannelIds(null, ret);
return ret;
}
+ public number clone_ptr() {
+ number ret = bindings.RawDataPart_clone_ptr(this.ptr);
+ return ret;
+ }
+
public RawDataPart clone() {
number ret = bindings.RawDataPart_clone(this.ptr);
const ret_hu_conv: RawDataPart = new RawDataPart(null, ret);
return ret;
}
+ public number clone_ptr() {
+ number ret = bindings.RawInvoice_clone_ptr(this.ptr);
+ return ret;
+ }
+
public RawInvoice clone() {
number ret = bindings.RawInvoice_clone(this.ptr);
const ret_hu_conv: RawInvoice = new RawInvoice(null, ret);
}
}
public Option_CVec_NetAddressZZ get_addresses(Uint8Array pubkey) {
- number ret = bindings.ReadOnlyNetworkGraph_get_addresses(this.ptr, pubkey);
+ number ret = bindings.ReadOnlyNetworkGraph_get_addresses(this.ptr, InternalUtils.check_arr_len(pubkey, 33));
Option_CVec_NetAddressZZ ret_hu_conv = Option_CVec_NetAddressZZ.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(this);
return ret_hu_conv;
--- /dev/null
+
+
+import CommonBase from './CommonBase';
+import * as bindings from '../bindings' // TODO: figure out location
+
+
+
+ export default class Record extends CommonBase {
+ constructor(_dummy: object, ptr: number) {
+ super(ptr);
+ }
+
+
+ protected finalize() {
+ super.finalize();
+
+ if (this.ptr != 0) {
+ bindings.Record_free(this.ptr);
+ }
+ }
+ public Level get_level() {
+ Level ret = bindings.Record_get_level(this.ptr);
+ return ret;
+ }
+
+ public void set_level(Level val) {
+ bindings.Record_set_level(this.ptr, val);
+ }
+
+ public String get_args() {
+ String ret = bindings.Record_get_args(this.ptr);
+ return ret;
+ }
+
+ public void set_args(String val) {
+ bindings.Record_set_args(this.ptr, val);
+ }
+
+ public String get_module_path() {
+ String ret = bindings.Record_get_module_path(this.ptr);
+ return ret;
+ }
+
+ public void set_module_path(String val) {
+ bindings.Record_set_module_path(this.ptr, val);
+ }
+
+ public String get_file() {
+ String ret = bindings.Record_get_file(this.ptr);
+ return ret;
+ }
+
+ public void set_file(String val) {
+ bindings.Record_set_file(this.ptr, val);
+ }
+
+ public number get_line() {
+ number ret = bindings.Record_get_line(this.ptr);
+ return ret;
+ }
+
+ public void set_line(number val) {
+ bindings.Record_set_line(this.ptr, val);
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.Record_clone_ptr(this.ptr);
+ return ret;
+ }
+
+ public Record clone() {
+ number ret = bindings.Record_clone(this.ptr);
+ const ret_hu_conv: Record = new Record(null, ret);
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+}
}
public void set_chain_hash(Uint8Array val) {
- bindings.ReplyChannelRange_set_chain_hash(this.ptr, val);
+ bindings.ReplyChannelRange_set_chain_hash(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public number get_first_blocknum() {
}
public static ReplyChannelRange constructor_new(Uint8Array chain_hash_arg, number first_blocknum_arg, number number_of_blocks_arg, boolean sync_complete_arg, number[] short_channel_ids_arg) {
- number ret = bindings.ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
+ number ret = bindings.ReplyChannelRange_new(InternalUtils.check_arr_len(chain_hash_arg, 32), first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
const ret_hu_conv: ReplyChannelRange = new ReplyChannelRange(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.ReplyChannelRange_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ReplyChannelRange clone() {
number ret = bindings.ReplyChannelRange_clone(this.ptr);
const ret_hu_conv: ReplyChannelRange = new ReplyChannelRange(null, ret);
}
public void set_chain_hash(Uint8Array val) {
- bindings.ReplyShortChannelIdsEnd_set_chain_hash(this.ptr, val);
+ bindings.ReplyShortChannelIdsEnd_set_chain_hash(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public boolean get_full_information() {
}
public static ReplyShortChannelIdsEnd constructor_new(Uint8Array chain_hash_arg, boolean full_information_arg) {
- number ret = bindings.ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
+ number ret = bindings.ReplyShortChannelIdsEnd_new(InternalUtils.check_arr_len(chain_hash_arg, 32), full_information_arg);
const ret_hu_conv: ReplyShortChannelIdsEnd = new ReplyShortChannelIdsEnd(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.ReplyShortChannelIdsEnd_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ReplyShortChannelIdsEnd clone() {
number ret = bindings.ReplyShortChannelIdsEnd_clone(this.ptr);
const ret_hu_conv: ReplyShortChannelIdsEnd = new ReplyShortChannelIdsEnd(null, ret);
}
static Result_AcceptChannelDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_AcceptChannelDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_AcceptChannelDecodeErrorZ_is_ok(ptr)) {
return new Result_AcceptChannelDecodeErrorZ_OK(null, ptr);
} else {
return new Result_AcceptChannelDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_AcceptChannelDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_AcceptChannelDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_AcceptChannelDecodeErrorZ clone() {
number ret = bindings.CResult_AcceptChannelDecodeErrorZ_clone(this.ptr);
Result_AcceptChannelDecodeErrorZ ret_hu_conv = Result_AcceptChannelDecodeErrorZ.constr_from_ptr(ret);
}
static Result_AnnouncementSignaturesDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_AnnouncementSignaturesDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(ptr)) {
return new Result_AnnouncementSignaturesDecodeErrorZ_OK(null, ptr);
} else {
return new Result_AnnouncementSignaturesDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_AnnouncementSignaturesDecodeErrorZ clone() {
number ret = bindings.CResult_AnnouncementSignaturesDecodeErrorZ_clone(this.ptr);
Result_AnnouncementSignaturesDecodeErrorZ ret_hu_conv = Result_AnnouncementSignaturesDecodeErrorZ.constr_from_ptr(ret);
}
static Result_BuiltCommitmentTransactionDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_BuiltCommitmentTransactionDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(ptr)) {
return new Result_BuiltCommitmentTransactionDecodeErrorZ_OK(null, ptr);
} else {
return new Result_BuiltCommitmentTransactionDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_BuiltCommitmentTransactionDecodeErrorZ clone() {
number ret = bindings.CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(this.ptr);
Result_BuiltCommitmentTransactionDecodeErrorZ ret_hu_conv = Result_BuiltCommitmentTransactionDecodeErrorZ.constr_from_ptr(ret);
}
static Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(ptr)) {
return new Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_OK(null, ptr);
} else {
return new Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
}
}
static Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(ptr)) {
return new Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_OK(null, ptr);
} else {
return new Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ clone() {
number ret = bindings.CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(this.ptr);
Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ ret_hu_conv = Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ.constr_from_ptr(ret);
}
static Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_result_ok(ptr)) {
+ if (bindings.CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(ptr)) {
return new Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_OK(null, ptr);
} else {
return new Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ clone() {
number ret = bindings.CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(this.ptr);
Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ ret_hu_conv = Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ.constr_from_ptr(ret);
}
static Result_C2Tuple_SignatureCVec_SignatureZZNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(ptr)) {
return new Result_C2Tuple_SignatureCVec_SignatureZZNoneZ_OK(null, ptr);
} else {
return new Result_C2Tuple_SignatureCVec_SignatureZZNoneZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_C2Tuple_SignatureCVec_SignatureZZNoneZ clone() {
number ret = bindings.CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(this.ptr);
Result_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_hu_conv = Result_C2Tuple_SignatureCVec_SignatureZZNoneZ.constr_from_ptr(ret);
--- /dev/null
+
+import CommonBase from './CommonBase';
+import * as bindings from '../bindings' // TODO: figure out location
+
+public class Result_COption_ClosureReasonZDecodeErrorZ extends CommonBase {
+ private Result_COption_ClosureReasonZDecodeErrorZ(Object _dummy, long ptr) { super(ptr); }
+ protected void finalize() throws Throwable {
+ if (ptr != 0) { bindings.CResult_COption_ClosureReasonZDecodeErrorZ_free(ptr); } super.finalize();
+ }
+
+ static Result_COption_ClosureReasonZDecodeErrorZ constr_from_ptr(long ptr) {
+ if (bindings.CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(ptr)) {
+ return new Result_COption_ClosureReasonZDecodeErrorZ_OK(null, ptr);
+ } else {
+ return new Result_COption_ClosureReasonZDecodeErrorZ_Err(null, ptr);
+ }
+ }
+ public static final class Result_COption_ClosureReasonZDecodeErrorZ_OK extends Result_COption_ClosureReasonZDecodeErrorZ {
+ public final Option_ClosureReasonZ res;
+ private Result_COption_ClosureReasonZDecodeErrorZ_OK(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ number res = bindings.LDKCResult_COption_ClosureReasonZDecodeErrorZ_get_ok(ptr);
+ Option_ClosureReasonZ res_hu_conv = Option_ClosureReasonZ.constr_from_ptr(res);
+ res_hu_conv.ptrs_to.add(this);
+ this.res = res_hu_conv;
+ }
+ }
+
+ public static final class Result_COption_ClosureReasonZDecodeErrorZ_Err extends Result_COption_ClosureReasonZDecodeErrorZ {
+ public final DecodeError err;
+ private Result_COption_ClosureReasonZDecodeErrorZ_Err(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ number err = bindings.LDKCResult_COption_ClosureReasonZDecodeErrorZ_get_err(ptr);
+ const err_hu_conv: DecodeError = new DecodeError(null, err);
+ err_hu_conv.ptrs_to.add(this);
+ this.err = err_hu_conv;
+ }
+ }
+
+ public static Result_COption_ClosureReasonZDecodeErrorZ constructor_ok(Option_ClosureReasonZ o) {
+ number ret = bindings.CResult_COption_ClosureReasonZDecodeErrorZ_ok(o.ptr);
+ Result_COption_ClosureReasonZDecodeErrorZ ret_hu_conv = Result_COption_ClosureReasonZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ public static Result_COption_ClosureReasonZDecodeErrorZ constructor_err(DecodeError e) {
+ number ret = bindings.CResult_COption_ClosureReasonZDecodeErrorZ_err(e == null ? 0 : e.ptr & ~1);
+ Result_COption_ClosureReasonZDecodeErrorZ ret_hu_conv = Result_COption_ClosureReasonZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
+ public Result_COption_ClosureReasonZDecodeErrorZ clone() {
+ number ret = bindings.CResult_COption_ClosureReasonZDecodeErrorZ_clone(this.ptr);
+ Result_COption_ClosureReasonZDecodeErrorZ ret_hu_conv = Result_COption_ClosureReasonZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+}
--- /dev/null
+
+import CommonBase from './CommonBase';
+import * as bindings from '../bindings' // TODO: figure out location
+
+public class Result_COption_EventZDecodeErrorZ extends CommonBase {
+ private Result_COption_EventZDecodeErrorZ(Object _dummy, long ptr) { super(ptr); }
+ protected void finalize() throws Throwable {
+ if (ptr != 0) { bindings.CResult_COption_EventZDecodeErrorZ_free(ptr); } super.finalize();
+ }
+
+ static Result_COption_EventZDecodeErrorZ constr_from_ptr(long ptr) {
+ if (bindings.CResult_COption_EventZDecodeErrorZ_is_ok(ptr)) {
+ return new Result_COption_EventZDecodeErrorZ_OK(null, ptr);
+ } else {
+ return new Result_COption_EventZDecodeErrorZ_Err(null, ptr);
+ }
+ }
+ public static final class Result_COption_EventZDecodeErrorZ_OK extends Result_COption_EventZDecodeErrorZ {
+ public final Option_EventZ res;
+ private Result_COption_EventZDecodeErrorZ_OK(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ number res = bindings.LDKCResult_COption_EventZDecodeErrorZ_get_ok(ptr);
+ Option_EventZ res_hu_conv = Option_EventZ.constr_from_ptr(res);
+ res_hu_conv.ptrs_to.add(this);
+ this.res = res_hu_conv;
+ }
+ }
+
+ public static final class Result_COption_EventZDecodeErrorZ_Err extends Result_COption_EventZDecodeErrorZ {
+ public final DecodeError err;
+ private Result_COption_EventZDecodeErrorZ_Err(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ number err = bindings.LDKCResult_COption_EventZDecodeErrorZ_get_err(ptr);
+ const err_hu_conv: DecodeError = new DecodeError(null, err);
+ err_hu_conv.ptrs_to.add(this);
+ this.err = err_hu_conv;
+ }
+ }
+
+ public static Result_COption_EventZDecodeErrorZ constructor_ok(Option_EventZ o) {
+ number ret = bindings.CResult_COption_EventZDecodeErrorZ_ok(o.ptr);
+ Result_COption_EventZDecodeErrorZ ret_hu_conv = Result_COption_EventZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ public static Result_COption_EventZDecodeErrorZ constructor_err(DecodeError e) {
+ number ret = bindings.CResult_COption_EventZDecodeErrorZ_err(e == null ? 0 : e.ptr & ~1);
+ Result_COption_EventZDecodeErrorZ ret_hu_conv = Result_COption_EventZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_COption_EventZDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_COption_EventZDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
+ public Result_COption_EventZDecodeErrorZ clone() {
+ number ret = bindings.CResult_COption_EventZDecodeErrorZ_clone(this.ptr);
+ Result_COption_EventZDecodeErrorZ ret_hu_conv = Result_COption_EventZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+}
--- /dev/null
+
+import CommonBase from './CommonBase';
+import * as bindings from '../bindings' // TODO: figure out location
+
+public class Result_COption_MonitorEventZDecodeErrorZ extends CommonBase {
+ private Result_COption_MonitorEventZDecodeErrorZ(Object _dummy, long ptr) { super(ptr); }
+ protected void finalize() throws Throwable {
+ if (ptr != 0) { bindings.CResult_COption_MonitorEventZDecodeErrorZ_free(ptr); } super.finalize();
+ }
+
+ static Result_COption_MonitorEventZDecodeErrorZ constr_from_ptr(long ptr) {
+ if (bindings.CResult_COption_MonitorEventZDecodeErrorZ_is_ok(ptr)) {
+ return new Result_COption_MonitorEventZDecodeErrorZ_OK(null, ptr);
+ } else {
+ return new Result_COption_MonitorEventZDecodeErrorZ_Err(null, ptr);
+ }
+ }
+ public static final class Result_COption_MonitorEventZDecodeErrorZ_OK extends Result_COption_MonitorEventZDecodeErrorZ {
+ public final Option_MonitorEventZ res;
+ private Result_COption_MonitorEventZDecodeErrorZ_OK(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ number res = bindings.LDKCResult_COption_MonitorEventZDecodeErrorZ_get_ok(ptr);
+ Option_MonitorEventZ res_hu_conv = Option_MonitorEventZ.constr_from_ptr(res);
+ res_hu_conv.ptrs_to.add(this);
+ this.res = res_hu_conv;
+ }
+ }
+
+ public static final class Result_COption_MonitorEventZDecodeErrorZ_Err extends Result_COption_MonitorEventZDecodeErrorZ {
+ public final DecodeError err;
+ private Result_COption_MonitorEventZDecodeErrorZ_Err(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ number err = bindings.LDKCResult_COption_MonitorEventZDecodeErrorZ_get_err(ptr);
+ const err_hu_conv: DecodeError = new DecodeError(null, err);
+ err_hu_conv.ptrs_to.add(this);
+ this.err = err_hu_conv;
+ }
+ }
+
+ public static Result_COption_MonitorEventZDecodeErrorZ constructor_ok(Option_MonitorEventZ o) {
+ number ret = bindings.CResult_COption_MonitorEventZDecodeErrorZ_ok(o.ptr);
+ Result_COption_MonitorEventZDecodeErrorZ ret_hu_conv = Result_COption_MonitorEventZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ public static Result_COption_MonitorEventZDecodeErrorZ constructor_err(DecodeError e) {
+ number ret = bindings.CResult_COption_MonitorEventZDecodeErrorZ_err(e == null ? 0 : e.ptr & ~1);
+ Result_COption_MonitorEventZDecodeErrorZ ret_hu_conv = Result_COption_MonitorEventZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_COption_MonitorEventZDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
+ public Result_COption_MonitorEventZDecodeErrorZ clone() {
+ number ret = bindings.CResult_COption_MonitorEventZDecodeErrorZ_clone(this.ptr);
+ Result_COption_MonitorEventZDecodeErrorZ ret_hu_conv = Result_COption_MonitorEventZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+}
--- /dev/null
+
+import CommonBase from './CommonBase';
+import * as bindings from '../bindings' // TODO: figure out location
+
+public class Result_COption_NetworkUpdateZDecodeErrorZ extends CommonBase {
+ private Result_COption_NetworkUpdateZDecodeErrorZ(Object _dummy, long ptr) { super(ptr); }
+ protected void finalize() throws Throwable {
+ if (ptr != 0) { bindings.CResult_COption_NetworkUpdateZDecodeErrorZ_free(ptr); } super.finalize();
+ }
+
+ static Result_COption_NetworkUpdateZDecodeErrorZ constr_from_ptr(long ptr) {
+ if (bindings.CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(ptr)) {
+ return new Result_COption_NetworkUpdateZDecodeErrorZ_OK(null, ptr);
+ } else {
+ return new Result_COption_NetworkUpdateZDecodeErrorZ_Err(null, ptr);
+ }
+ }
+ public static final class Result_COption_NetworkUpdateZDecodeErrorZ_OK extends Result_COption_NetworkUpdateZDecodeErrorZ {
+ public final Option_NetworkUpdateZ res;
+ private Result_COption_NetworkUpdateZDecodeErrorZ_OK(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ number res = bindings.LDKCResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(ptr);
+ Option_NetworkUpdateZ res_hu_conv = Option_NetworkUpdateZ.constr_from_ptr(res);
+ res_hu_conv.ptrs_to.add(this);
+ this.res = res_hu_conv;
+ }
+ }
+
+ public static final class Result_COption_NetworkUpdateZDecodeErrorZ_Err extends Result_COption_NetworkUpdateZDecodeErrorZ {
+ public final DecodeError err;
+ private Result_COption_NetworkUpdateZDecodeErrorZ_Err(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ number err = bindings.LDKCResult_COption_NetworkUpdateZDecodeErrorZ_get_err(ptr);
+ const err_hu_conv: DecodeError = new DecodeError(null, err);
+ err_hu_conv.ptrs_to.add(this);
+ this.err = err_hu_conv;
+ }
+ }
+
+ public static Result_COption_NetworkUpdateZDecodeErrorZ constructor_ok(Option_NetworkUpdateZ o) {
+ number ret = bindings.CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o.ptr);
+ Result_COption_NetworkUpdateZDecodeErrorZ ret_hu_conv = Result_COption_NetworkUpdateZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ public static Result_COption_NetworkUpdateZDecodeErrorZ constructor_err(DecodeError e) {
+ number ret = bindings.CResult_COption_NetworkUpdateZDecodeErrorZ_err(e == null ? 0 : e.ptr & ~1);
+ Result_COption_NetworkUpdateZDecodeErrorZ ret_hu_conv = Result_COption_NetworkUpdateZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
+ public Result_COption_NetworkUpdateZDecodeErrorZ clone() {
+ number ret = bindings.CResult_COption_NetworkUpdateZDecodeErrorZ_clone(this.ptr);
+ Result_COption_NetworkUpdateZDecodeErrorZ ret_hu_conv = Result_COption_NetworkUpdateZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+}
}
static Result_COption_TypeZDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_COption_TypeZDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_COption_TypeZDecodeErrorZ_is_ok(ptr)) {
return new Result_COption_TypeZDecodeErrorZ_OK(null, ptr);
} else {
return new Result_COption_TypeZDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_COption_TypeZDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_COption_TypeZDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_COption_TypeZDecodeErrorZ clone() {
number ret = bindings.CResult_COption_TypeZDecodeErrorZ_clone(this.ptr);
Result_COption_TypeZDecodeErrorZ ret_hu_conv = Result_COption_TypeZDecodeErrorZ.constr_from_ptr(ret);
}
static Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_is_ok(ptr)) {
return new Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_OK(null, ptr);
} else {
return new Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ clone() {
number ret = bindings.CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone(this.ptr);
Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ ret_hu_conv = Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ.constr_from_ptr(ret);
}
static Result_CVec_CVec_u8ZZNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_CVec_CVec_u8ZZNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_CVec_CVec_u8ZZNoneZ_is_ok(ptr)) {
return new Result_CVec_CVec_u8ZZNoneZ_OK(null, ptr);
} else {
return new Result_CVec_CVec_u8ZZNoneZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_CVec_CVec_u8ZZNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_CVec_CVec_u8ZZNoneZ clone() {
number ret = bindings.CResult_CVec_CVec_u8ZZNoneZ_clone(this.ptr);
Result_CVec_CVec_u8ZZNoneZ ret_hu_conv = Result_CVec_CVec_u8ZZNoneZ.constr_from_ptr(ret);
}
static Result_CVec_SignatureZNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_CVec_SignatureZNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_CVec_SignatureZNoneZ_is_ok(ptr)) {
return new Result_CVec_SignatureZNoneZ_OK(null, ptr);
} else {
return new Result_CVec_SignatureZNoneZ_Err(null, ptr);
}
public static Result_CVec_SignatureZNoneZ constructor_ok(Uint8Array[] o) {
- number ret = bindings.CResult_CVec_SignatureZNoneZ_ok(o);
+ number ret = bindings.CResult_CVec_SignatureZNoneZ_ok(o != null ? Arrays.stream(o).map(o_conv_12 -> InternalUtils.check_arr_len(o_conv_12, 64)).toArray(Uint8Array[]::new) : null);
Result_CVec_SignatureZNoneZ ret_hu_conv = Result_CVec_SignatureZNoneZ.constr_from_ptr(ret);
return ret_hu_conv;
}
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_CVec_SignatureZNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_CVec_SignatureZNoneZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_CVec_SignatureZNoneZ clone() {
number ret = bindings.CResult_CVec_SignatureZNoneZ_clone(this.ptr);
Result_CVec_SignatureZNoneZ ret_hu_conv = Result_CVec_SignatureZNoneZ.constr_from_ptr(ret);
}
static Result_CVec_u8ZPeerHandleErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_CVec_u8ZPeerHandleErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_CVec_u8ZPeerHandleErrorZ_is_ok(ptr)) {
return new Result_CVec_u8ZPeerHandleErrorZ_OK(null, ptr);
} else {
return new Result_CVec_u8ZPeerHandleErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_CVec_u8ZPeerHandleErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_CVec_u8ZPeerHandleErrorZ clone() {
number ret = bindings.CResult_CVec_u8ZPeerHandleErrorZ_clone(this.ptr);
Result_CVec_u8ZPeerHandleErrorZ ret_hu_conv = Result_CVec_u8ZPeerHandleErrorZ.constr_from_ptr(ret);
}
static Result_ChannelAnnouncementDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ChannelAnnouncementDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ChannelAnnouncementDecodeErrorZ_is_ok(ptr)) {
return new Result_ChannelAnnouncementDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ChannelAnnouncementDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ChannelAnnouncementDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_ChannelAnnouncementDecodeErrorZ clone() {
number ret = bindings.CResult_ChannelAnnouncementDecodeErrorZ_clone(this.ptr);
Result_ChannelAnnouncementDecodeErrorZ ret_hu_conv = Result_ChannelAnnouncementDecodeErrorZ.constr_from_ptr(ret);
}
static Result_ChannelConfigDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ChannelConfigDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ChannelConfigDecodeErrorZ_is_ok(ptr)) {
return new Result_ChannelConfigDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ChannelConfigDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ChannelConfigDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_ChannelConfigDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_ChannelConfigDecodeErrorZ clone() {
number ret = bindings.CResult_ChannelConfigDecodeErrorZ_clone(this.ptr);
Result_ChannelConfigDecodeErrorZ ret_hu_conv = Result_ChannelConfigDecodeErrorZ.constr_from_ptr(ret);
}
static Result_ChannelFeaturesDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ChannelFeaturesDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ChannelFeaturesDecodeErrorZ_is_ok(ptr)) {
return new Result_ChannelFeaturesDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ChannelFeaturesDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ChannelFeaturesDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
}
}
static Result_ChannelInfoDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ChannelInfoDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ChannelInfoDecodeErrorZ_is_ok(ptr)) {
return new Result_ChannelInfoDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ChannelInfoDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ChannelInfoDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_ChannelInfoDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_ChannelInfoDecodeErrorZ clone() {
number ret = bindings.CResult_ChannelInfoDecodeErrorZ_clone(this.ptr);
Result_ChannelInfoDecodeErrorZ ret_hu_conv = Result_ChannelInfoDecodeErrorZ.constr_from_ptr(ret);
}
static Result_ChannelMonitorUpdateDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ChannelMonitorUpdateDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(ptr)) {
return new Result_ChannelMonitorUpdateDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ChannelMonitorUpdateDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_ChannelMonitorUpdateDecodeErrorZ clone() {
number ret = bindings.CResult_ChannelMonitorUpdateDecodeErrorZ_clone(this.ptr);
Result_ChannelMonitorUpdateDecodeErrorZ ret_hu_conv = Result_ChannelMonitorUpdateDecodeErrorZ.constr_from_ptr(ret);
}
static Result_ChannelPublicKeysDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ChannelPublicKeysDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ChannelPublicKeysDecodeErrorZ_is_ok(ptr)) {
return new Result_ChannelPublicKeysDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ChannelPublicKeysDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ChannelPublicKeysDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_ChannelPublicKeysDecodeErrorZ clone() {
number ret = bindings.CResult_ChannelPublicKeysDecodeErrorZ_clone(this.ptr);
Result_ChannelPublicKeysDecodeErrorZ ret_hu_conv = Result_ChannelPublicKeysDecodeErrorZ.constr_from_ptr(ret);
}
static Result_ChannelReestablishDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ChannelReestablishDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ChannelReestablishDecodeErrorZ_is_ok(ptr)) {
return new Result_ChannelReestablishDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ChannelReestablishDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ChannelReestablishDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_ChannelReestablishDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_ChannelReestablishDecodeErrorZ clone() {
number ret = bindings.CResult_ChannelReestablishDecodeErrorZ_clone(this.ptr);
Result_ChannelReestablishDecodeErrorZ ret_hu_conv = Result_ChannelReestablishDecodeErrorZ.constr_from_ptr(ret);
}
static Result_ChannelTransactionParametersDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ChannelTransactionParametersDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(ptr)) {
return new Result_ChannelTransactionParametersDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ChannelTransactionParametersDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_ChannelTransactionParametersDecodeErrorZ clone() {
number ret = bindings.CResult_ChannelTransactionParametersDecodeErrorZ_clone(this.ptr);
Result_ChannelTransactionParametersDecodeErrorZ ret_hu_conv = Result_ChannelTransactionParametersDecodeErrorZ.constr_from_ptr(ret);
}
static Result_ChannelUpdateDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ChannelUpdateDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ChannelUpdateDecodeErrorZ_is_ok(ptr)) {
return new Result_ChannelUpdateDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ChannelUpdateDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ChannelUpdateDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_ChannelUpdateDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_ChannelUpdateDecodeErrorZ clone() {
number ret = bindings.CResult_ChannelUpdateDecodeErrorZ_clone(this.ptr);
Result_ChannelUpdateDecodeErrorZ ret_hu_conv = Result_ChannelUpdateDecodeErrorZ.constr_from_ptr(ret);
}
static Result_ClosingSignedDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ClosingSignedDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ClosingSignedDecodeErrorZ_is_ok(ptr)) {
return new Result_ClosingSignedDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ClosingSignedDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ClosingSignedDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_ClosingSignedDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_ClosingSignedDecodeErrorZ clone() {
number ret = bindings.CResult_ClosingSignedDecodeErrorZ_clone(this.ptr);
Result_ClosingSignedDecodeErrorZ ret_hu_conv = Result_ClosingSignedDecodeErrorZ.constr_from_ptr(ret);
}
static Result_ClosingSignedFeeRangeDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ClosingSignedFeeRangeDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(ptr)) {
return new Result_ClosingSignedFeeRangeDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ClosingSignedFeeRangeDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_ClosingSignedFeeRangeDecodeErrorZ clone() {
number ret = bindings.CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(this.ptr);
Result_ClosingSignedFeeRangeDecodeErrorZ ret_hu_conv = Result_ClosingSignedFeeRangeDecodeErrorZ.constr_from_ptr(ret);
}
static Result_CommitmentSignedDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_CommitmentSignedDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_CommitmentSignedDecodeErrorZ_is_ok(ptr)) {
return new Result_CommitmentSignedDecodeErrorZ_OK(null, ptr);
} else {
return new Result_CommitmentSignedDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_CommitmentSignedDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_CommitmentSignedDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_CommitmentSignedDecodeErrorZ clone() {
number ret = bindings.CResult_CommitmentSignedDecodeErrorZ_clone(this.ptr);
Result_CommitmentSignedDecodeErrorZ ret_hu_conv = Result_CommitmentSignedDecodeErrorZ.constr_from_ptr(ret);
}
static Result_CommitmentTransactionDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_CommitmentTransactionDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_CommitmentTransactionDecodeErrorZ_is_ok(ptr)) {
return new Result_CommitmentTransactionDecodeErrorZ_OK(null, ptr);
} else {
return new Result_CommitmentTransactionDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_CommitmentTransactionDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_CommitmentTransactionDecodeErrorZ clone() {
number ret = bindings.CResult_CommitmentTransactionDecodeErrorZ_clone(this.ptr);
Result_CommitmentTransactionDecodeErrorZ ret_hu_conv = Result_CommitmentTransactionDecodeErrorZ.constr_from_ptr(ret);
}
static Result_CounterpartyChannelTransactionParametersDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(ptr)) {
return new Result_CounterpartyChannelTransactionParametersDecodeErrorZ_OK(null, ptr);
} else {
return new Result_CounterpartyChannelTransactionParametersDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_CounterpartyChannelTransactionParametersDecodeErrorZ clone() {
number ret = bindings.CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(this.ptr);
Result_CounterpartyChannelTransactionParametersDecodeErrorZ ret_hu_conv = Result_CounterpartyChannelTransactionParametersDecodeErrorZ.constr_from_ptr(ret);
}
static Result_DelayedPaymentOutputDescriptorDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(ptr)) {
return new Result_DelayedPaymentOutputDescriptorDecodeErrorZ_OK(null, ptr);
} else {
return new Result_DelayedPaymentOutputDescriptorDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_DelayedPaymentOutputDescriptorDecodeErrorZ clone() {
number ret = bindings.CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(this.ptr);
Result_DelayedPaymentOutputDescriptorDecodeErrorZ ret_hu_conv = Result_DelayedPaymentOutputDescriptorDecodeErrorZ.constr_from_ptr(ret);
}
static Result_DescriptionCreationErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_DescriptionCreationErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_DescriptionCreationErrorZ_is_ok(ptr)) {
return new Result_DescriptionCreationErrorZ_OK(null, ptr);
} else {
return new Result_DescriptionCreationErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_DescriptionCreationErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_DescriptionCreationErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_DescriptionCreationErrorZ clone() {
number ret = bindings.CResult_DescriptionCreationErrorZ_clone(this.ptr);
Result_DescriptionCreationErrorZ ret_hu_conv = Result_DescriptionCreationErrorZ.constr_from_ptr(ret);
}
static Result_DirectionalChannelInfoDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_DirectionalChannelInfoDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(ptr)) {
return new Result_DirectionalChannelInfoDecodeErrorZ_OK(null, ptr);
} else {
return new Result_DirectionalChannelInfoDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_DirectionalChannelInfoDecodeErrorZ clone() {
number ret = bindings.CResult_DirectionalChannelInfoDecodeErrorZ_clone(this.ptr);
Result_DirectionalChannelInfoDecodeErrorZ ret_hu_conv = Result_DirectionalChannelInfoDecodeErrorZ.constr_from_ptr(ret);
}
static Result_ErrorMessageDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ErrorMessageDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ErrorMessageDecodeErrorZ_is_ok(ptr)) {
return new Result_ErrorMessageDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ErrorMessageDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ErrorMessageDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_ErrorMessageDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_ErrorMessageDecodeErrorZ clone() {
number ret = bindings.CResult_ErrorMessageDecodeErrorZ_clone(this.ptr);
Result_ErrorMessageDecodeErrorZ ret_hu_conv = Result_ErrorMessageDecodeErrorZ.constr_from_ptr(ret);
}
static Result_ExpiryTimeCreationErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ExpiryTimeCreationErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ExpiryTimeCreationErrorZ_is_ok(ptr)) {
return new Result_ExpiryTimeCreationErrorZ_OK(null, ptr);
} else {
return new Result_ExpiryTimeCreationErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ExpiryTimeCreationErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_ExpiryTimeCreationErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_ExpiryTimeCreationErrorZ clone() {
number ret = bindings.CResult_ExpiryTimeCreationErrorZ_clone(this.ptr);
Result_ExpiryTimeCreationErrorZ ret_hu_conv = Result_ExpiryTimeCreationErrorZ.constr_from_ptr(ret);
}
static Result_FundingCreatedDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_FundingCreatedDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_FundingCreatedDecodeErrorZ_is_ok(ptr)) {
return new Result_FundingCreatedDecodeErrorZ_OK(null, ptr);
} else {
return new Result_FundingCreatedDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_FundingCreatedDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_FundingCreatedDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_FundingCreatedDecodeErrorZ clone() {
number ret = bindings.CResult_FundingCreatedDecodeErrorZ_clone(this.ptr);
Result_FundingCreatedDecodeErrorZ ret_hu_conv = Result_FundingCreatedDecodeErrorZ.constr_from_ptr(ret);
}
static Result_FundingLockedDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_FundingLockedDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_FundingLockedDecodeErrorZ_is_ok(ptr)) {
return new Result_FundingLockedDecodeErrorZ_OK(null, ptr);
} else {
return new Result_FundingLockedDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_FundingLockedDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_FundingLockedDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_FundingLockedDecodeErrorZ clone() {
number ret = bindings.CResult_FundingLockedDecodeErrorZ_clone(this.ptr);
Result_FundingLockedDecodeErrorZ ret_hu_conv = Result_FundingLockedDecodeErrorZ.constr_from_ptr(ret);
}
static Result_FundingSignedDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_FundingSignedDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_FundingSignedDecodeErrorZ_is_ok(ptr)) {
return new Result_FundingSignedDecodeErrorZ_OK(null, ptr);
} else {
return new Result_FundingSignedDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_FundingSignedDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_FundingSignedDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_FundingSignedDecodeErrorZ clone() {
number ret = bindings.CResult_FundingSignedDecodeErrorZ_clone(this.ptr);
Result_FundingSignedDecodeErrorZ ret_hu_conv = Result_FundingSignedDecodeErrorZ.constr_from_ptr(ret);
}
static Result_GossipTimestampFilterDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_GossipTimestampFilterDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_GossipTimestampFilterDecodeErrorZ_is_ok(ptr)) {
return new Result_GossipTimestampFilterDecodeErrorZ_OK(null, ptr);
} else {
return new Result_GossipTimestampFilterDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_GossipTimestampFilterDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_GossipTimestampFilterDecodeErrorZ clone() {
number ret = bindings.CResult_GossipTimestampFilterDecodeErrorZ_clone(this.ptr);
Result_GossipTimestampFilterDecodeErrorZ ret_hu_conv = Result_GossipTimestampFilterDecodeErrorZ.constr_from_ptr(ret);
}
static Result_HTLCOutputInCommitmentDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(ptr)) {
return new Result_HTLCOutputInCommitmentDecodeErrorZ_OK(null, ptr);
} else {
return new Result_HTLCOutputInCommitmentDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_HTLCOutputInCommitmentDecodeErrorZ clone() {
number ret = bindings.CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(this.ptr);
Result_HTLCOutputInCommitmentDecodeErrorZ ret_hu_conv = Result_HTLCOutputInCommitmentDecodeErrorZ.constr_from_ptr(ret);
}
static Result_HTLCUpdateDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_HTLCUpdateDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_HTLCUpdateDecodeErrorZ_is_ok(ptr)) {
return new Result_HTLCUpdateDecodeErrorZ_OK(null, ptr);
} else {
return new Result_HTLCUpdateDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_HTLCUpdateDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_HTLCUpdateDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_HTLCUpdateDecodeErrorZ clone() {
number ret = bindings.CResult_HTLCUpdateDecodeErrorZ_clone(this.ptr);
Result_HTLCUpdateDecodeErrorZ ret_hu_conv = Result_HTLCUpdateDecodeErrorZ.constr_from_ptr(ret);
}
static Result_HolderCommitmentTransactionDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_HolderCommitmentTransactionDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(ptr)) {
return new Result_HolderCommitmentTransactionDecodeErrorZ_OK(null, ptr);
} else {
return new Result_HolderCommitmentTransactionDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_HolderCommitmentTransactionDecodeErrorZ clone() {
number ret = bindings.CResult_HolderCommitmentTransactionDecodeErrorZ_clone(this.ptr);
Result_HolderCommitmentTransactionDecodeErrorZ ret_hu_conv = Result_HolderCommitmentTransactionDecodeErrorZ.constr_from_ptr(ret);
}
static Result_InMemorySignerDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_InMemorySignerDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_InMemorySignerDecodeErrorZ_is_ok(ptr)) {
return new Result_InMemorySignerDecodeErrorZ_OK(null, ptr);
} else {
return new Result_InMemorySignerDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_InMemorySignerDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_InMemorySignerDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_InMemorySignerDecodeErrorZ clone() {
number ret = bindings.CResult_InMemorySignerDecodeErrorZ_clone(this.ptr);
Result_InMemorySignerDecodeErrorZ ret_hu_conv = Result_InMemorySignerDecodeErrorZ.constr_from_ptr(ret);
}
static Result_InitDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_InitDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_InitDecodeErrorZ_is_ok(ptr)) {
return new Result_InitDecodeErrorZ_OK(null, ptr);
} else {
return new Result_InitDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_InitDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_InitDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_InitDecodeErrorZ clone() {
number ret = bindings.CResult_InitDecodeErrorZ_clone(this.ptr);
Result_InitDecodeErrorZ ret_hu_conv = Result_InitDecodeErrorZ.constr_from_ptr(ret);
}
static Result_InitFeaturesDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_InitFeaturesDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_InitFeaturesDecodeErrorZ_is_ok(ptr)) {
return new Result_InitFeaturesDecodeErrorZ_OK(null, ptr);
} else {
return new Result_InitFeaturesDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_InitFeaturesDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
}
}
static Result_InvoiceFeaturesDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_InvoiceFeaturesDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_InvoiceFeaturesDecodeErrorZ_is_ok(ptr)) {
return new Result_InvoiceFeaturesDecodeErrorZ_OK(null, ptr);
} else {
return new Result_InvoiceFeaturesDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_InvoiceFeaturesDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
}
}
static Result_InvoiceNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_InvoiceNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_InvoiceNoneZ_is_ok(ptr)) {
return new Result_InvoiceNoneZ_OK(null, ptr);
} else {
return new Result_InvoiceNoneZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_InvoiceNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_InvoiceNoneZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_InvoiceNoneZ clone() {
number ret = bindings.CResult_InvoiceNoneZ_clone(this.ptr);
Result_InvoiceNoneZ ret_hu_conv = Result_InvoiceNoneZ.constr_from_ptr(ret);
}
static Result_InvoiceSemanticErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_InvoiceSemanticErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_InvoiceSemanticErrorZ_is_ok(ptr)) {
return new Result_InvoiceSemanticErrorZ_OK(null, ptr);
} else {
return new Result_InvoiceSemanticErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_InvoiceSemanticErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_InvoiceSemanticErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_InvoiceSemanticErrorZ clone() {
number ret = bindings.CResult_InvoiceSemanticErrorZ_clone(this.ptr);
Result_InvoiceSemanticErrorZ ret_hu_conv = Result_InvoiceSemanticErrorZ.constr_from_ptr(ret);
}
static Result_InvoiceSignOrCreationErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_InvoiceSignOrCreationErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_InvoiceSignOrCreationErrorZ_is_ok(ptr)) {
return new Result_InvoiceSignOrCreationErrorZ_OK(null, ptr);
} else {
return new Result_InvoiceSignOrCreationErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_InvoiceSignOrCreationErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_InvoiceSignOrCreationErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_InvoiceSignOrCreationErrorZ clone() {
number ret = bindings.CResult_InvoiceSignOrCreationErrorZ_clone(this.ptr);
Result_InvoiceSignOrCreationErrorZ ret_hu_conv = Result_InvoiceSignOrCreationErrorZ.constr_from_ptr(ret);
}
static Result_LockedChannelMonitorNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_LockedChannelMonitorNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_LockedChannelMonitorNoneZ_is_ok(ptr)) {
return new Result_LockedChannelMonitorNoneZ_OK(null, ptr);
} else {
return new Result_LockedChannelMonitorNoneZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_LockedChannelMonitorNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
}
}
static Result_NetAddressDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NetAddressDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NetAddressDecodeErrorZ_is_ok(ptr)) {
return new Result_NetAddressDecodeErrorZ_OK(null, ptr);
} else {
return new Result_NetAddressDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NetAddressDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_NetAddressDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_NetAddressDecodeErrorZ clone() {
number ret = bindings.CResult_NetAddressDecodeErrorZ_clone(this.ptr);
Result_NetAddressDecodeErrorZ ret_hu_conv = Result_NetAddressDecodeErrorZ.constr_from_ptr(ret);
}
static Result_NetworkGraphDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NetworkGraphDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NetworkGraphDecodeErrorZ_is_ok(ptr)) {
return new Result_NetworkGraphDecodeErrorZ_OK(null, ptr);
} else {
return new Result_NetworkGraphDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NetworkGraphDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_NetworkGraphDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_NetworkGraphDecodeErrorZ clone() {
number ret = bindings.CResult_NetworkGraphDecodeErrorZ_clone(this.ptr);
Result_NetworkGraphDecodeErrorZ ret_hu_conv = Result_NetworkGraphDecodeErrorZ.constr_from_ptr(ret);
}
static Result_NodeAnnouncementDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NodeAnnouncementDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NodeAnnouncementDecodeErrorZ_is_ok(ptr)) {
return new Result_NodeAnnouncementDecodeErrorZ_OK(null, ptr);
} else {
return new Result_NodeAnnouncementDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NodeAnnouncementDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_NodeAnnouncementDecodeErrorZ clone() {
number ret = bindings.CResult_NodeAnnouncementDecodeErrorZ_clone(this.ptr);
Result_NodeAnnouncementDecodeErrorZ ret_hu_conv = Result_NodeAnnouncementDecodeErrorZ.constr_from_ptr(ret);
}
static Result_NodeAnnouncementInfoDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NodeAnnouncementInfoDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(ptr)) {
return new Result_NodeAnnouncementInfoDecodeErrorZ_OK(null, ptr);
} else {
return new Result_NodeAnnouncementInfoDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_NodeAnnouncementInfoDecodeErrorZ clone() {
number ret = bindings.CResult_NodeAnnouncementInfoDecodeErrorZ_clone(this.ptr);
Result_NodeAnnouncementInfoDecodeErrorZ ret_hu_conv = Result_NodeAnnouncementInfoDecodeErrorZ.constr_from_ptr(ret);
}
static Result_NodeFeaturesDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NodeFeaturesDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NodeFeaturesDecodeErrorZ_is_ok(ptr)) {
return new Result_NodeFeaturesDecodeErrorZ_OK(null, ptr);
} else {
return new Result_NodeFeaturesDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NodeFeaturesDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
}
}
static Result_NodeIdDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NodeIdDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NodeIdDecodeErrorZ_is_ok(ptr)) {
return new Result_NodeIdDecodeErrorZ_OK(null, ptr);
} else {
return new Result_NodeIdDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NodeIdDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_NodeIdDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_NodeIdDecodeErrorZ clone() {
number ret = bindings.CResult_NodeIdDecodeErrorZ_clone(this.ptr);
Result_NodeIdDecodeErrorZ ret_hu_conv = Result_NodeIdDecodeErrorZ.constr_from_ptr(ret);
}
static Result_NodeInfoDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NodeInfoDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NodeInfoDecodeErrorZ_is_ok(ptr)) {
return new Result_NodeInfoDecodeErrorZ_OK(null, ptr);
} else {
return new Result_NodeInfoDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NodeInfoDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_NodeInfoDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_NodeInfoDecodeErrorZ clone() {
number ret = bindings.CResult_NodeInfoDecodeErrorZ_clone(this.ptr);
Result_NodeInfoDecodeErrorZ ret_hu_conv = Result_NodeInfoDecodeErrorZ.constr_from_ptr(ret);
}
static Result_NoneAPIErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NoneAPIErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NoneAPIErrorZ_is_ok(ptr)) {
return new Result_NoneAPIErrorZ_OK(null, ptr);
} else {
return new Result_NoneAPIErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NoneAPIErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_NoneAPIErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_NoneAPIErrorZ clone() {
number ret = bindings.CResult_NoneAPIErrorZ_clone(this.ptr);
Result_NoneAPIErrorZ ret_hu_conv = Result_NoneAPIErrorZ.constr_from_ptr(ret);
}
static Result_NoneChannelMonitorUpdateErrZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NoneChannelMonitorUpdateErrZ_result_ok(ptr)) {
+ if (bindings.CResult_NoneChannelMonitorUpdateErrZ_is_ok(ptr)) {
return new Result_NoneChannelMonitorUpdateErrZ_OK(null, ptr);
} else {
return new Result_NoneChannelMonitorUpdateErrZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NoneChannelMonitorUpdateErrZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_NoneChannelMonitorUpdateErrZ clone() {
number ret = bindings.CResult_NoneChannelMonitorUpdateErrZ_clone(this.ptr);
Result_NoneChannelMonitorUpdateErrZ ret_hu_conv = Result_NoneChannelMonitorUpdateErrZ.constr_from_ptr(ret);
}
static Result_NoneErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NoneErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NoneErrorZ_is_ok(ptr)) {
return new Result_NoneErrorZ_OK(null, ptr);
} else {
return new Result_NoneErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NoneErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_NoneErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_NoneErrorZ clone() {
number ret = bindings.CResult_NoneErrorZ_clone(this.ptr);
Result_NoneErrorZ ret_hu_conv = Result_NoneErrorZ.constr_from_ptr(ret);
}
static Result_NoneLightningErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NoneLightningErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NoneLightningErrorZ_is_ok(ptr)) {
return new Result_NoneLightningErrorZ_OK(null, ptr);
} else {
return new Result_NoneLightningErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NoneLightningErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_NoneLightningErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_NoneLightningErrorZ clone() {
number ret = bindings.CResult_NoneLightningErrorZ_clone(this.ptr);
Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
}
static Result_NoneMonitorUpdateErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NoneMonitorUpdateErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NoneMonitorUpdateErrorZ_is_ok(ptr)) {
return new Result_NoneMonitorUpdateErrorZ_OK(null, ptr);
} else {
return new Result_NoneMonitorUpdateErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NoneMonitorUpdateErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_NoneMonitorUpdateErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_NoneMonitorUpdateErrorZ clone() {
number ret = bindings.CResult_NoneMonitorUpdateErrorZ_clone(this.ptr);
Result_NoneMonitorUpdateErrorZ ret_hu_conv = Result_NoneMonitorUpdateErrorZ.constr_from_ptr(ret);
}
static Result_NoneNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NoneNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_NoneNoneZ_is_ok(ptr)) {
return new Result_NoneNoneZ_OK(null, ptr);
} else {
return new Result_NoneNoneZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NoneNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_NoneNoneZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_NoneNoneZ clone() {
number ret = bindings.CResult_NoneNoneZ_clone(this.ptr);
Result_NoneNoneZ ret_hu_conv = Result_NoneNoneZ.constr_from_ptr(ret);
}
static Result_NonePaymentSendFailureZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NonePaymentSendFailureZ_result_ok(ptr)) {
+ if (bindings.CResult_NonePaymentSendFailureZ_is_ok(ptr)) {
return new Result_NonePaymentSendFailureZ_OK(null, ptr);
} else {
return new Result_NonePaymentSendFailureZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NonePaymentSendFailureZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_NonePaymentSendFailureZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_NonePaymentSendFailureZ clone() {
number ret = bindings.CResult_NonePaymentSendFailureZ_clone(this.ptr);
Result_NonePaymentSendFailureZ ret_hu_conv = Result_NonePaymentSendFailureZ.constr_from_ptr(ret);
}
static Result_NonePeerHandleErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NonePeerHandleErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NonePeerHandleErrorZ_is_ok(ptr)) {
return new Result_NonePeerHandleErrorZ_OK(null, ptr);
} else {
return new Result_NonePeerHandleErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NonePeerHandleErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_NonePeerHandleErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_NonePeerHandleErrorZ clone() {
number ret = bindings.CResult_NonePeerHandleErrorZ_clone(this.ptr);
Result_NonePeerHandleErrorZ ret_hu_conv = Result_NonePeerHandleErrorZ.constr_from_ptr(ret);
}
static Result_NoneSemanticErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_NoneSemanticErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_NoneSemanticErrorZ_is_ok(ptr)) {
return new Result_NoneSemanticErrorZ_OK(null, ptr);
} else {
return new Result_NoneSemanticErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_NoneSemanticErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_NoneSemanticErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_NoneSemanticErrorZ clone() {
number ret = bindings.CResult_NoneSemanticErrorZ_clone(this.ptr);
Result_NoneSemanticErrorZ ret_hu_conv = Result_NoneSemanticErrorZ.constr_from_ptr(ret);
}
static Result_OpenChannelDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_OpenChannelDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_OpenChannelDecodeErrorZ_is_ok(ptr)) {
return new Result_OpenChannelDecodeErrorZ_OK(null, ptr);
} else {
return new Result_OpenChannelDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_OpenChannelDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_OpenChannelDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_OpenChannelDecodeErrorZ clone() {
number ret = bindings.CResult_OpenChannelDecodeErrorZ_clone(this.ptr);
Result_OpenChannelDecodeErrorZ ret_hu_conv = Result_OpenChannelDecodeErrorZ.constr_from_ptr(ret);
}
static Result_OutPointDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_OutPointDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_OutPointDecodeErrorZ_is_ok(ptr)) {
return new Result_OutPointDecodeErrorZ_OK(null, ptr);
} else {
return new Result_OutPointDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_OutPointDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_OutPointDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_OutPointDecodeErrorZ clone() {
number ret = bindings.CResult_OutPointDecodeErrorZ_clone(this.ptr);
Result_OutPointDecodeErrorZ ret_hu_conv = Result_OutPointDecodeErrorZ.constr_from_ptr(ret);
}
static Result_PayeeDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_PayeeDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_PayeeDecodeErrorZ_is_ok(ptr)) {
return new Result_PayeeDecodeErrorZ_OK(null, ptr);
} else {
return new Result_PayeeDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_PayeeDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_PayeeDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_PayeeDecodeErrorZ clone() {
number ret = bindings.CResult_PayeeDecodeErrorZ_clone(this.ptr);
Result_PayeeDecodeErrorZ ret_hu_conv = Result_PayeeDecodeErrorZ.constr_from_ptr(ret);
}
static Result_PayeePubKeyErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_PayeePubKeyErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_PayeePubKeyErrorZ_is_ok(ptr)) {
return new Result_PayeePubKeyErrorZ_OK(null, ptr);
} else {
return new Result_PayeePubKeyErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_PayeePubKeyErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_PayeePubKeyErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_PayeePubKeyErrorZ clone() {
number ret = bindings.CResult_PayeePubKeyErrorZ_clone(this.ptr);
Result_PayeePubKeyErrorZ ret_hu_conv = Result_PayeePubKeyErrorZ.constr_from_ptr(ret);
}
static Result_PaymentIdPaymentErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_PaymentIdPaymentErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_PaymentIdPaymentErrorZ_is_ok(ptr)) {
return new Result_PaymentIdPaymentErrorZ_OK(null, ptr);
} else {
return new Result_PaymentIdPaymentErrorZ_Err(null, ptr);
}
public static Result_PaymentIdPaymentErrorZ constructor_ok(Uint8Array o) {
- number ret = bindings.CResult_PaymentIdPaymentErrorZ_ok(o);
+ number ret = bindings.CResult_PaymentIdPaymentErrorZ_ok(InternalUtils.check_arr_len(o, 32));
Result_PaymentIdPaymentErrorZ ret_hu_conv = Result_PaymentIdPaymentErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_PaymentIdPaymentErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_PaymentIdPaymentErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_PaymentIdPaymentErrorZ clone() {
number ret = bindings.CResult_PaymentIdPaymentErrorZ_clone(this.ptr);
Result_PaymentIdPaymentErrorZ ret_hu_conv = Result_PaymentIdPaymentErrorZ.constr_from_ptr(ret);
}
static Result_PaymentIdPaymentSendFailureZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_PaymentIdPaymentSendFailureZ_result_ok(ptr)) {
+ if (bindings.CResult_PaymentIdPaymentSendFailureZ_is_ok(ptr)) {
return new Result_PaymentIdPaymentSendFailureZ_OK(null, ptr);
} else {
return new Result_PaymentIdPaymentSendFailureZ_Err(null, ptr);
}
public static Result_PaymentIdPaymentSendFailureZ constructor_ok(Uint8Array o) {
- number ret = bindings.CResult_PaymentIdPaymentSendFailureZ_ok(o);
+ number ret = bindings.CResult_PaymentIdPaymentSendFailureZ_ok(InternalUtils.check_arr_len(o, 32));
Result_PaymentIdPaymentSendFailureZ ret_hu_conv = Result_PaymentIdPaymentSendFailureZ.constr_from_ptr(ret);
return ret_hu_conv;
}
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_PaymentIdPaymentSendFailureZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_PaymentIdPaymentSendFailureZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_PaymentIdPaymentSendFailureZ clone() {
number ret = bindings.CResult_PaymentIdPaymentSendFailureZ_clone(this.ptr);
Result_PaymentIdPaymentSendFailureZ ret_hu_conv = Result_PaymentIdPaymentSendFailureZ.constr_from_ptr(ret);
}
static Result_PaymentSecretAPIErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_PaymentSecretAPIErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_PaymentSecretAPIErrorZ_is_ok(ptr)) {
return new Result_PaymentSecretAPIErrorZ_OK(null, ptr);
} else {
return new Result_PaymentSecretAPIErrorZ_Err(null, ptr);
}
public static Result_PaymentSecretAPIErrorZ constructor_ok(Uint8Array o) {
- number ret = bindings.CResult_PaymentSecretAPIErrorZ_ok(o);
+ number ret = bindings.CResult_PaymentSecretAPIErrorZ_ok(InternalUtils.check_arr_len(o, 32));
Result_PaymentSecretAPIErrorZ ret_hu_conv = Result_PaymentSecretAPIErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_PaymentSecretAPIErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_PaymentSecretAPIErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_PaymentSecretAPIErrorZ clone() {
number ret = bindings.CResult_PaymentSecretAPIErrorZ_clone(this.ptr);
Result_PaymentSecretAPIErrorZ ret_hu_conv = Result_PaymentSecretAPIErrorZ.constr_from_ptr(ret);
}
static Result_PingDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_PingDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_PingDecodeErrorZ_is_ok(ptr)) {
return new Result_PingDecodeErrorZ_OK(null, ptr);
} else {
return new Result_PingDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_PingDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_PingDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_PingDecodeErrorZ clone() {
number ret = bindings.CResult_PingDecodeErrorZ_clone(this.ptr);
Result_PingDecodeErrorZ ret_hu_conv = Result_PingDecodeErrorZ.constr_from_ptr(ret);
}
static Result_PongDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_PongDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_PongDecodeErrorZ_is_ok(ptr)) {
return new Result_PongDecodeErrorZ_OK(null, ptr);
} else {
return new Result_PongDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_PongDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_PongDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_PongDecodeErrorZ clone() {
number ret = bindings.CResult_PongDecodeErrorZ_clone(this.ptr);
Result_PongDecodeErrorZ ret_hu_conv = Result_PongDecodeErrorZ.constr_from_ptr(ret);
}
static Result_PositiveTimestampCreationErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_PositiveTimestampCreationErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_PositiveTimestampCreationErrorZ_is_ok(ptr)) {
return new Result_PositiveTimestampCreationErrorZ_OK(null, ptr);
} else {
return new Result_PositiveTimestampCreationErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_PositiveTimestampCreationErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_PositiveTimestampCreationErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_PositiveTimestampCreationErrorZ clone() {
number ret = bindings.CResult_PositiveTimestampCreationErrorZ_clone(this.ptr);
Result_PositiveTimestampCreationErrorZ ret_hu_conv = Result_PositiveTimestampCreationErrorZ.constr_from_ptr(ret);
}
static Result_PrivateRouteCreationErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_PrivateRouteCreationErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_PrivateRouteCreationErrorZ_is_ok(ptr)) {
return new Result_PrivateRouteCreationErrorZ_OK(null, ptr);
} else {
return new Result_PrivateRouteCreationErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_PrivateRouteCreationErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_PrivateRouteCreationErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_PrivateRouteCreationErrorZ clone() {
number ret = bindings.CResult_PrivateRouteCreationErrorZ_clone(this.ptr);
Result_PrivateRouteCreationErrorZ ret_hu_conv = Result_PrivateRouteCreationErrorZ.constr_from_ptr(ret);
}
static Result_PublicKeyErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_PublicKeyErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_PublicKeyErrorZ_is_ok(ptr)) {
return new Result_PublicKeyErrorZ_OK(null, ptr);
} else {
return new Result_PublicKeyErrorZ_Err(null, ptr);
}
public static Result_PublicKeyErrorZ constructor_ok(Uint8Array o) {
- number ret = bindings.CResult_PublicKeyErrorZ_ok(o);
+ number ret = bindings.CResult_PublicKeyErrorZ_ok(InternalUtils.check_arr_len(o, 33));
Result_PublicKeyErrorZ ret_hu_conv = Result_PublicKeyErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_PublicKeyErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_PublicKeyErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_PublicKeyErrorZ clone() {
number ret = bindings.CResult_PublicKeyErrorZ_clone(this.ptr);
Result_PublicKeyErrorZ ret_hu_conv = Result_PublicKeyErrorZ.constr_from_ptr(ret);
}
static Result_QueryChannelRangeDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_QueryChannelRangeDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_QueryChannelRangeDecodeErrorZ_is_ok(ptr)) {
return new Result_QueryChannelRangeDecodeErrorZ_OK(null, ptr);
} else {
return new Result_QueryChannelRangeDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_QueryChannelRangeDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_QueryChannelRangeDecodeErrorZ clone() {
number ret = bindings.CResult_QueryChannelRangeDecodeErrorZ_clone(this.ptr);
Result_QueryChannelRangeDecodeErrorZ ret_hu_conv = Result_QueryChannelRangeDecodeErrorZ.constr_from_ptr(ret);
}
static Result_QueryShortChannelIdsDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_QueryShortChannelIdsDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(ptr)) {
return new Result_QueryShortChannelIdsDecodeErrorZ_OK(null, ptr);
} else {
return new Result_QueryShortChannelIdsDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_QueryShortChannelIdsDecodeErrorZ clone() {
number ret = bindings.CResult_QueryShortChannelIdsDecodeErrorZ_clone(this.ptr);
Result_QueryShortChannelIdsDecodeErrorZ ret_hu_conv = Result_QueryShortChannelIdsDecodeErrorZ.constr_from_ptr(ret);
}
static Result_RecoverableSignatureNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_RecoverableSignatureNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_RecoverableSignatureNoneZ_is_ok(ptr)) {
return new Result_RecoverableSignatureNoneZ_OK(null, ptr);
} else {
return new Result_RecoverableSignatureNoneZ_Err(null, ptr);
}
public static Result_RecoverableSignatureNoneZ constructor_ok(Uint8Array arg) {
- number ret = bindings.CResult_RecoverableSignatureNoneZ_ok(arg);
+ number ret = bindings.CResult_RecoverableSignatureNoneZ_ok(InternalUtils.check_arr_len(arg, 68));
Result_RecoverableSignatureNoneZ ret_hu_conv = Result_RecoverableSignatureNoneZ.constr_from_ptr(ret);
return ret_hu_conv;
}
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_RecoverableSignatureNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_RecoverableSignatureNoneZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_RecoverableSignatureNoneZ clone() {
number ret = bindings.CResult_RecoverableSignatureNoneZ_clone(this.ptr);
Result_RecoverableSignatureNoneZ ret_hu_conv = Result_RecoverableSignatureNoneZ.constr_from_ptr(ret);
}
static Result_ReplyChannelRangeDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ReplyChannelRangeDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ReplyChannelRangeDecodeErrorZ_is_ok(ptr)) {
return new Result_ReplyChannelRangeDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ReplyChannelRangeDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ReplyChannelRangeDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_ReplyChannelRangeDecodeErrorZ clone() {
number ret = bindings.CResult_ReplyChannelRangeDecodeErrorZ_clone(this.ptr);
Result_ReplyChannelRangeDecodeErrorZ ret_hu_conv = Result_ReplyChannelRangeDecodeErrorZ.constr_from_ptr(ret);
}
static Result_ReplyShortChannelIdsEndDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(ptr)) {
return new Result_ReplyShortChannelIdsEndDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ReplyShortChannelIdsEndDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_ReplyShortChannelIdsEndDecodeErrorZ clone() {
number ret = bindings.CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(this.ptr);
Result_ReplyShortChannelIdsEndDecodeErrorZ ret_hu_conv = Result_ReplyShortChannelIdsEndDecodeErrorZ.constr_from_ptr(ret);
}
static Result_RevokeAndACKDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_RevokeAndACKDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_RevokeAndACKDecodeErrorZ_is_ok(ptr)) {
return new Result_RevokeAndACKDecodeErrorZ_OK(null, ptr);
} else {
return new Result_RevokeAndACKDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_RevokeAndACKDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_RevokeAndACKDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_RevokeAndACKDecodeErrorZ clone() {
number ret = bindings.CResult_RevokeAndACKDecodeErrorZ_clone(this.ptr);
Result_RevokeAndACKDecodeErrorZ ret_hu_conv = Result_RevokeAndACKDecodeErrorZ.constr_from_ptr(ret);
}
static Result_RouteDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_RouteDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_RouteDecodeErrorZ_is_ok(ptr)) {
return new Result_RouteDecodeErrorZ_OK(null, ptr);
} else {
return new Result_RouteDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_RouteDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_RouteDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_RouteDecodeErrorZ clone() {
number ret = bindings.CResult_RouteDecodeErrorZ_clone(this.ptr);
Result_RouteDecodeErrorZ ret_hu_conv = Result_RouteDecodeErrorZ.constr_from_ptr(ret);
}
static Result_RouteHintDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_RouteHintDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_RouteHintDecodeErrorZ_is_ok(ptr)) {
return new Result_RouteHintDecodeErrorZ_OK(null, ptr);
} else {
return new Result_RouteHintDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_RouteHintDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_RouteHintDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_RouteHintDecodeErrorZ clone() {
number ret = bindings.CResult_RouteHintDecodeErrorZ_clone(this.ptr);
Result_RouteHintDecodeErrorZ ret_hu_conv = Result_RouteHintDecodeErrorZ.constr_from_ptr(ret);
}
static Result_RouteHintHopDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_RouteHintHopDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_RouteHintHopDecodeErrorZ_is_ok(ptr)) {
return new Result_RouteHintHopDecodeErrorZ_OK(null, ptr);
} else {
return new Result_RouteHintHopDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_RouteHintHopDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_RouteHintHopDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_RouteHintHopDecodeErrorZ clone() {
number ret = bindings.CResult_RouteHintHopDecodeErrorZ_clone(this.ptr);
Result_RouteHintHopDecodeErrorZ ret_hu_conv = Result_RouteHintHopDecodeErrorZ.constr_from_ptr(ret);
}
static Result_RouteHopDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_RouteHopDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_RouteHopDecodeErrorZ_is_ok(ptr)) {
return new Result_RouteHopDecodeErrorZ_OK(null, ptr);
} else {
return new Result_RouteHopDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_RouteHopDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_RouteHopDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_RouteHopDecodeErrorZ clone() {
number ret = bindings.CResult_RouteHopDecodeErrorZ_clone(this.ptr);
Result_RouteHopDecodeErrorZ ret_hu_conv = Result_RouteHopDecodeErrorZ.constr_from_ptr(ret);
}
static Result_RouteLightningErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_RouteLightningErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_RouteLightningErrorZ_is_ok(ptr)) {
return new Result_RouteLightningErrorZ_OK(null, ptr);
} else {
return new Result_RouteLightningErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_RouteLightningErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_RouteLightningErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_RouteLightningErrorZ clone() {
number ret = bindings.CResult_RouteLightningErrorZ_clone(this.ptr);
Result_RouteLightningErrorZ ret_hu_conv = Result_RouteLightningErrorZ.constr_from_ptr(ret);
}
static Result_RouteParametersDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_RouteParametersDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_RouteParametersDecodeErrorZ_is_ok(ptr)) {
return new Result_RouteParametersDecodeErrorZ_OK(null, ptr);
} else {
return new Result_RouteParametersDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_RouteParametersDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_RouteParametersDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_RouteParametersDecodeErrorZ clone() {
number ret = bindings.CResult_RouteParametersDecodeErrorZ_clone(this.ptr);
Result_RouteParametersDecodeErrorZ ret_hu_conv = Result_RouteParametersDecodeErrorZ.constr_from_ptr(ret);
}
static Result_RoutingFeesDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_RoutingFeesDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_RoutingFeesDecodeErrorZ_is_ok(ptr)) {
return new Result_RoutingFeesDecodeErrorZ_OK(null, ptr);
} else {
return new Result_RoutingFeesDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_RoutingFeesDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_RoutingFeesDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_RoutingFeesDecodeErrorZ clone() {
number ret = bindings.CResult_RoutingFeesDecodeErrorZ_clone(this.ptr);
Result_RoutingFeesDecodeErrorZ ret_hu_conv = Result_RoutingFeesDecodeErrorZ.constr_from_ptr(ret);
--- /dev/null
+
+import CommonBase from './CommonBase';
+import * as bindings from '../bindings' // TODO: figure out location
+
+public class Result_ScorerDecodeErrorZ extends CommonBase {
+ private Result_ScorerDecodeErrorZ(Object _dummy, long ptr) { super(ptr); }
+ protected void finalize() throws Throwable {
+ if (ptr != 0) { bindings.CResult_ScorerDecodeErrorZ_free(ptr); } super.finalize();
+ }
+
+ static Result_ScorerDecodeErrorZ constr_from_ptr(long ptr) {
+ if (bindings.CResult_ScorerDecodeErrorZ_is_ok(ptr)) {
+ return new Result_ScorerDecodeErrorZ_OK(null, ptr);
+ } else {
+ return new Result_ScorerDecodeErrorZ_Err(null, ptr);
+ }
+ }
+ public static final class Result_ScorerDecodeErrorZ_OK extends Result_ScorerDecodeErrorZ {
+ public final Scorer res;
+ private Result_ScorerDecodeErrorZ_OK(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ number res = bindings.LDKCResult_ScorerDecodeErrorZ_get_ok(ptr);
+ const res_hu_conv: Scorer = new Scorer(null, res);
+ res_hu_conv.ptrs_to.add(this);
+ this.res = res_hu_conv;
+ }
+ }
+
+ public static final class Result_ScorerDecodeErrorZ_Err extends Result_ScorerDecodeErrorZ {
+ public final DecodeError err;
+ private Result_ScorerDecodeErrorZ_Err(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ number err = bindings.LDKCResult_ScorerDecodeErrorZ_get_err(ptr);
+ const err_hu_conv: DecodeError = new DecodeError(null, err);
+ err_hu_conv.ptrs_to.add(this);
+ this.err = err_hu_conv;
+ }
+ }
+
+ public static Result_ScorerDecodeErrorZ constructor_ok(ScoringParameters o_params) {
+ number ret = bindings.CResult_ScorerDecodeErrorZ_ok(bindings.Scorer_new(o_params == null ? 0 : o_params.ptr & ~1));
+ Result_ScorerDecodeErrorZ ret_hu_conv = Result_ScorerDecodeErrorZ.constr_from_ptr(ret);
+ ret_hu_conv.ptrs_to.add(o_params);
+// Due to rust's strict-ownership memory model, in some cases we need to "move"
+// an object to pass exclusive ownership to the function being called.
+// In most cases, we avoid ret_hu_conv being visible in GC'd languages by cloning the object
+// at the FFI layer, creating a new object which Rust can claim ownership of
+// However, in some cases (eg here), there is no way to clone an object, and thus
+// we actually have to pass full ownership to Rust.
+// Thus, after ret_hu_conv call, o_params is reset to null and is now a dummy object.
+o_params.ptr = 0;
+ return ret_hu_conv;
+ }
+
+ public static Result_ScorerDecodeErrorZ constructor_err(DecodeError e) {
+ number ret = bindings.CResult_ScorerDecodeErrorZ_err(e == null ? 0 : e.ptr & ~1);
+ Result_ScorerDecodeErrorZ ret_hu_conv = Result_ScorerDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ScorerDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+}
--- /dev/null
+
+import CommonBase from './CommonBase';
+import * as bindings from '../bindings' // TODO: figure out location
+
+public class Result_ScoringParametersDecodeErrorZ extends CommonBase {
+ private Result_ScoringParametersDecodeErrorZ(Object _dummy, long ptr) { super(ptr); }
+ protected void finalize() throws Throwable {
+ if (ptr != 0) { bindings.CResult_ScoringParametersDecodeErrorZ_free(ptr); } super.finalize();
+ }
+
+ static Result_ScoringParametersDecodeErrorZ constr_from_ptr(long ptr) {
+ if (bindings.CResult_ScoringParametersDecodeErrorZ_is_ok(ptr)) {
+ return new Result_ScoringParametersDecodeErrorZ_OK(null, ptr);
+ } else {
+ return new Result_ScoringParametersDecodeErrorZ_Err(null, ptr);
+ }
+ }
+ public static final class Result_ScoringParametersDecodeErrorZ_OK extends Result_ScoringParametersDecodeErrorZ {
+ public final ScoringParameters res;
+ private Result_ScoringParametersDecodeErrorZ_OK(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ number res = bindings.LDKCResult_ScoringParametersDecodeErrorZ_get_ok(ptr);
+ const res_hu_conv: ScoringParameters = new ScoringParameters(null, res);
+ res_hu_conv.ptrs_to.add(this);
+ this.res = res_hu_conv;
+ }
+ }
+
+ public static final class Result_ScoringParametersDecodeErrorZ_Err extends Result_ScoringParametersDecodeErrorZ {
+ public final DecodeError err;
+ private Result_ScoringParametersDecodeErrorZ_Err(Object _dummy, long ptr) {
+ super(_dummy, ptr);
+ number err = bindings.LDKCResult_ScoringParametersDecodeErrorZ_get_err(ptr);
+ const err_hu_conv: DecodeError = new DecodeError(null, err);
+ err_hu_conv.ptrs_to.add(this);
+ this.err = err_hu_conv;
+ }
+ }
+
+ public static Result_ScoringParametersDecodeErrorZ constructor_ok(number o_base_penalty_msat_arg, number o_failure_penalty_msat_arg, number o_failure_penalty_half_life_arg) {
+ number ret = bindings.CResult_ScoringParametersDecodeErrorZ_ok(bindings.ScoringParameters_new(o_base_penalty_msat_arg, o_failure_penalty_msat_arg, o_failure_penalty_half_life_arg));
+ Result_ScoringParametersDecodeErrorZ ret_hu_conv = Result_ScoringParametersDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ public static Result_ScoringParametersDecodeErrorZ constructor_err(DecodeError e) {
+ number ret = bindings.CResult_ScoringParametersDecodeErrorZ_err(e == null ? 0 : e.ptr & ~1);
+ Result_ScoringParametersDecodeErrorZ ret_hu_conv = Result_ScoringParametersDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ScoringParametersDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+}
}
static Result_SecretKeyErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_SecretKeyErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_SecretKeyErrorZ_is_ok(ptr)) {
return new Result_SecretKeyErrorZ_OK(null, ptr);
} else {
return new Result_SecretKeyErrorZ_Err(null, ptr);
}
public static Result_SecretKeyErrorZ constructor_ok(Uint8Array o) {
- number ret = bindings.CResult_SecretKeyErrorZ_ok(o);
+ number ret = bindings.CResult_SecretKeyErrorZ_ok(InternalUtils.check_arr_len(o, 32));
Result_SecretKeyErrorZ ret_hu_conv = Result_SecretKeyErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_SecretKeyErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
}
}
static Result_ShutdownDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ShutdownDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ShutdownDecodeErrorZ_is_ok(ptr)) {
return new Result_ShutdownDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ShutdownDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ShutdownDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_ShutdownDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_ShutdownDecodeErrorZ clone() {
number ret = bindings.CResult_ShutdownDecodeErrorZ_clone(this.ptr);
Result_ShutdownDecodeErrorZ ret_hu_conv = Result_ShutdownDecodeErrorZ.constr_from_ptr(ret);
}
static Result_ShutdownScriptDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ShutdownScriptDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_ShutdownScriptDecodeErrorZ_is_ok(ptr)) {
return new Result_ShutdownScriptDecodeErrorZ_OK(null, ptr);
} else {
return new Result_ShutdownScriptDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ShutdownScriptDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_ShutdownScriptDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_ShutdownScriptDecodeErrorZ clone() {
number ret = bindings.CResult_ShutdownScriptDecodeErrorZ_clone(this.ptr);
Result_ShutdownScriptDecodeErrorZ ret_hu_conv = Result_ShutdownScriptDecodeErrorZ.constr_from_ptr(ret);
}
static Result_ShutdownScriptInvalidShutdownScriptZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_ShutdownScriptInvalidShutdownScriptZ_result_ok(ptr)) {
+ if (bindings.CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(ptr)) {
return new Result_ShutdownScriptInvalidShutdownScriptZ_OK(null, ptr);
} else {
return new Result_ShutdownScriptInvalidShutdownScriptZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_ShutdownScriptInvalidShutdownScriptZ clone() {
number ret = bindings.CResult_ShutdownScriptInvalidShutdownScriptZ_clone(this.ptr);
Result_ShutdownScriptInvalidShutdownScriptZ ret_hu_conv = Result_ShutdownScriptInvalidShutdownScriptZ.constr_from_ptr(ret);
}
static Result_SiPrefixNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_SiPrefixNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_SiPrefixNoneZ_is_ok(ptr)) {
return new Result_SiPrefixNoneZ_OK(null, ptr);
} else {
return new Result_SiPrefixNoneZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_SiPrefixNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_SiPrefixNoneZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_SiPrefixNoneZ clone() {
number ret = bindings.CResult_SiPrefixNoneZ_clone(this.ptr);
Result_SiPrefixNoneZ ret_hu_conv = Result_SiPrefixNoneZ.constr_from_ptr(ret);
}
static Result_SignDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_SignDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_SignDecodeErrorZ_is_ok(ptr)) {
return new Result_SignDecodeErrorZ_OK(null, ptr);
} else {
return new Result_SignDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_SignDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_SignDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_SignDecodeErrorZ clone() {
number ret = bindings.CResult_SignDecodeErrorZ_clone(this.ptr);
Result_SignDecodeErrorZ ret_hu_conv = Result_SignDecodeErrorZ.constr_from_ptr(ret);
}
static Result_SignatureNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_SignatureNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_SignatureNoneZ_is_ok(ptr)) {
return new Result_SignatureNoneZ_OK(null, ptr);
} else {
return new Result_SignatureNoneZ_Err(null, ptr);
}
public static Result_SignatureNoneZ constructor_ok(Uint8Array o) {
- number ret = bindings.CResult_SignatureNoneZ_ok(o);
+ number ret = bindings.CResult_SignatureNoneZ_ok(InternalUtils.check_arr_len(o, 64));
Result_SignatureNoneZ ret_hu_conv = Result_SignatureNoneZ.constr_from_ptr(ret);
return ret_hu_conv;
}
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_SignatureNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_SignatureNoneZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_SignatureNoneZ clone() {
number ret = bindings.CResult_SignatureNoneZ_clone(this.ptr);
Result_SignatureNoneZ ret_hu_conv = Result_SignatureNoneZ.constr_from_ptr(ret);
}
static Result_SignedRawInvoiceNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_SignedRawInvoiceNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_SignedRawInvoiceNoneZ_is_ok(ptr)) {
return new Result_SignedRawInvoiceNoneZ_OK(null, ptr);
} else {
return new Result_SignedRawInvoiceNoneZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_SignedRawInvoiceNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_SignedRawInvoiceNoneZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_SignedRawInvoiceNoneZ clone() {
number ret = bindings.CResult_SignedRawInvoiceNoneZ_clone(this.ptr);
Result_SignedRawInvoiceNoneZ ret_hu_conv = Result_SignedRawInvoiceNoneZ.constr_from_ptr(ret);
}
static Result_SpendableOutputDescriptorDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_SpendableOutputDescriptorDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(ptr)) {
return new Result_SpendableOutputDescriptorDecodeErrorZ_OK(null, ptr);
} else {
return new Result_SpendableOutputDescriptorDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_SpendableOutputDescriptorDecodeErrorZ clone() {
number ret = bindings.CResult_SpendableOutputDescriptorDecodeErrorZ_clone(this.ptr);
Result_SpendableOutputDescriptorDecodeErrorZ ret_hu_conv = Result_SpendableOutputDescriptorDecodeErrorZ.constr_from_ptr(ret);
}
static Result_StaticPaymentOutputDescriptorDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(ptr)) {
return new Result_StaticPaymentOutputDescriptorDecodeErrorZ_OK(null, ptr);
} else {
return new Result_StaticPaymentOutputDescriptorDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_StaticPaymentOutputDescriptorDecodeErrorZ clone() {
number ret = bindings.CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(this.ptr);
Result_StaticPaymentOutputDescriptorDecodeErrorZ ret_hu_conv = Result_StaticPaymentOutputDescriptorDecodeErrorZ.constr_from_ptr(ret);
}
static Result_StringErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_StringErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_StringErrorZ_is_ok(ptr)) {
return new Result_StringErrorZ_OK(null, ptr);
} else {
return new Result_StringErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_StringErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
}
}
static Result_TransactionNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_TransactionNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_TransactionNoneZ_is_ok(ptr)) {
return new Result_TransactionNoneZ_OK(null, ptr);
} else {
return new Result_TransactionNoneZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_TransactionNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_TransactionNoneZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_TransactionNoneZ clone() {
number ret = bindings.CResult_TransactionNoneZ_clone(this.ptr);
Result_TransactionNoneZ ret_hu_conv = Result_TransactionNoneZ.constr_from_ptr(ret);
}
static Result_TrustedClosingTransactionNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_TrustedClosingTransactionNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_TrustedClosingTransactionNoneZ_is_ok(ptr)) {
return new Result_TrustedClosingTransactionNoneZ_OK(null, ptr);
} else {
return new Result_TrustedClosingTransactionNoneZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_TrustedClosingTransactionNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
}
}
static Result_TrustedCommitmentTransactionNoneZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_TrustedCommitmentTransactionNoneZ_result_ok(ptr)) {
+ if (bindings.CResult_TrustedCommitmentTransactionNoneZ_is_ok(ptr)) {
return new Result_TrustedCommitmentTransactionNoneZ_OK(null, ptr);
} else {
return new Result_TrustedCommitmentTransactionNoneZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_TrustedCommitmentTransactionNoneZ_is_ok(this.ptr);
+ return ret;
+ }
+
}
}
static Result_TxCreationKeysDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_TxCreationKeysDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_TxCreationKeysDecodeErrorZ_is_ok(ptr)) {
return new Result_TxCreationKeysDecodeErrorZ_OK(null, ptr);
} else {
return new Result_TxCreationKeysDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_TxCreationKeysDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_TxCreationKeysDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_TxCreationKeysDecodeErrorZ clone() {
number ret = bindings.CResult_TxCreationKeysDecodeErrorZ_clone(this.ptr);
Result_TxCreationKeysDecodeErrorZ ret_hu_conv = Result_TxCreationKeysDecodeErrorZ.constr_from_ptr(ret);
}
static Result_TxCreationKeysErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_TxCreationKeysErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_TxCreationKeysErrorZ_is_ok(ptr)) {
return new Result_TxCreationKeysErrorZ_OK(null, ptr);
} else {
return new Result_TxCreationKeysErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_TxCreationKeysErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_TxCreationKeysErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_TxCreationKeysErrorZ clone() {
number ret = bindings.CResult_TxCreationKeysErrorZ_clone(this.ptr);
Result_TxCreationKeysErrorZ ret_hu_conv = Result_TxCreationKeysErrorZ.constr_from_ptr(ret);
}
static Result_TxOutAccessErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_TxOutAccessErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_TxOutAccessErrorZ_is_ok(ptr)) {
return new Result_TxOutAccessErrorZ_OK(null, ptr);
} else {
return new Result_TxOutAccessErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_TxOutAccessErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_TxOutAccessErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_TxOutAccessErrorZ clone() {
number ret = bindings.CResult_TxOutAccessErrorZ_clone(this.ptr);
Result_TxOutAccessErrorZ ret_hu_conv = Result_TxOutAccessErrorZ.constr_from_ptr(ret);
}
static Result_UnsignedChannelAnnouncementDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(ptr)) {
return new Result_UnsignedChannelAnnouncementDecodeErrorZ_OK(null, ptr);
} else {
return new Result_UnsignedChannelAnnouncementDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_UnsignedChannelAnnouncementDecodeErrorZ clone() {
number ret = bindings.CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(this.ptr);
Result_UnsignedChannelAnnouncementDecodeErrorZ ret_hu_conv = Result_UnsignedChannelAnnouncementDecodeErrorZ.constr_from_ptr(ret);
}
static Result_UnsignedChannelUpdateDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_UnsignedChannelUpdateDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(ptr)) {
return new Result_UnsignedChannelUpdateDecodeErrorZ_OK(null, ptr);
} else {
return new Result_UnsignedChannelUpdateDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_UnsignedChannelUpdateDecodeErrorZ clone() {
number ret = bindings.CResult_UnsignedChannelUpdateDecodeErrorZ_clone(this.ptr);
Result_UnsignedChannelUpdateDecodeErrorZ ret_hu_conv = Result_UnsignedChannelUpdateDecodeErrorZ.constr_from_ptr(ret);
}
static Result_UnsignedNodeAnnouncementDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(ptr)) {
return new Result_UnsignedNodeAnnouncementDecodeErrorZ_OK(null, ptr);
} else {
return new Result_UnsignedNodeAnnouncementDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_UnsignedNodeAnnouncementDecodeErrorZ clone() {
number ret = bindings.CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(this.ptr);
Result_UnsignedNodeAnnouncementDecodeErrorZ ret_hu_conv = Result_UnsignedNodeAnnouncementDecodeErrorZ.constr_from_ptr(ret);
}
static Result_UpdateAddHTLCDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_UpdateAddHTLCDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_UpdateAddHTLCDecodeErrorZ_is_ok(ptr)) {
return new Result_UpdateAddHTLCDecodeErrorZ_OK(null, ptr);
} else {
return new Result_UpdateAddHTLCDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_UpdateAddHTLCDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_UpdateAddHTLCDecodeErrorZ clone() {
number ret = bindings.CResult_UpdateAddHTLCDecodeErrorZ_clone(this.ptr);
Result_UpdateAddHTLCDecodeErrorZ ret_hu_conv = Result_UpdateAddHTLCDecodeErrorZ.constr_from_ptr(ret);
}
static Result_UpdateFailHTLCDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_UpdateFailHTLCDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_UpdateFailHTLCDecodeErrorZ_is_ok(ptr)) {
return new Result_UpdateFailHTLCDecodeErrorZ_OK(null, ptr);
} else {
return new Result_UpdateFailHTLCDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_UpdateFailHTLCDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_UpdateFailHTLCDecodeErrorZ clone() {
number ret = bindings.CResult_UpdateFailHTLCDecodeErrorZ_clone(this.ptr);
Result_UpdateFailHTLCDecodeErrorZ ret_hu_conv = Result_UpdateFailHTLCDecodeErrorZ.constr_from_ptr(ret);
}
static Result_UpdateFailMalformedHTLCDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(ptr)) {
return new Result_UpdateFailMalformedHTLCDecodeErrorZ_OK(null, ptr);
} else {
return new Result_UpdateFailMalformedHTLCDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_UpdateFailMalformedHTLCDecodeErrorZ clone() {
number ret = bindings.CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(this.ptr);
Result_UpdateFailMalformedHTLCDecodeErrorZ ret_hu_conv = Result_UpdateFailMalformedHTLCDecodeErrorZ.constr_from_ptr(ret);
}
static Result_UpdateFeeDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_UpdateFeeDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_UpdateFeeDecodeErrorZ_is_ok(ptr)) {
return new Result_UpdateFeeDecodeErrorZ_OK(null, ptr);
} else {
return new Result_UpdateFeeDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_UpdateFeeDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_UpdateFeeDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_UpdateFeeDecodeErrorZ clone() {
number ret = bindings.CResult_UpdateFeeDecodeErrorZ_clone(this.ptr);
Result_UpdateFeeDecodeErrorZ ret_hu_conv = Result_UpdateFeeDecodeErrorZ.constr_from_ptr(ret);
}
static Result_UpdateFulfillHTLCDecodeErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_UpdateFulfillHTLCDecodeErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(ptr)) {
return new Result_UpdateFulfillHTLCDecodeErrorZ_OK(null, ptr);
} else {
return new Result_UpdateFulfillHTLCDecodeErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_UpdateFulfillHTLCDecodeErrorZ clone() {
number ret = bindings.CResult_UpdateFulfillHTLCDecodeErrorZ_clone(this.ptr);
Result_UpdateFulfillHTLCDecodeErrorZ ret_hu_conv = Result_UpdateFulfillHTLCDecodeErrorZ.constr_from_ptr(ret);
}
static Result__u832APIErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult__u832APIErrorZ_result_ok(ptr)) {
+ if (bindings.CResult__u832APIErrorZ_is_ok(ptr)) {
return new Result__u832APIErrorZ_OK(null, ptr);
} else {
return new Result__u832APIErrorZ_Err(null, ptr);
}
public static Result__u832APIErrorZ constructor_ok(Uint8Array o) {
- number ret = bindings.CResult__u832APIErrorZ_ok(o);
+ number ret = bindings.CResult__u832APIErrorZ_ok(InternalUtils.check_arr_len(o, 32));
Result__u832APIErrorZ ret_hu_conv = Result__u832APIErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult__u832APIErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult__u832APIErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result__u832APIErrorZ clone() {
number ret = bindings.CResult__u832APIErrorZ_clone(this.ptr);
Result__u832APIErrorZ ret_hu_conv = Result__u832APIErrorZ.constr_from_ptr(ret);
}
static Result_boolLightningErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_boolLightningErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_boolLightningErrorZ_is_ok(ptr)) {
return new Result_boolLightningErrorZ_OK(null, ptr);
} else {
return new Result_boolLightningErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_boolLightningErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_boolLightningErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_boolLightningErrorZ clone() {
number ret = bindings.CResult_boolLightningErrorZ_clone(this.ptr);
Result_boolLightningErrorZ ret_hu_conv = Result_boolLightningErrorZ.constr_from_ptr(ret);
}
static Result_boolPeerHandleErrorZ constr_from_ptr(long ptr) {
- if (bindings.LDKCResult_boolPeerHandleErrorZ_result_ok(ptr)) {
+ if (bindings.CResult_boolPeerHandleErrorZ_is_ok(ptr)) {
return new Result_boolPeerHandleErrorZ_OK(null, ptr);
} else {
return new Result_boolPeerHandleErrorZ_Err(null, ptr);
return ret_hu_conv;
}
+ public boolean is_ok() {
+ boolean ret = bindings.CResult_boolPeerHandleErrorZ_is_ok(this.ptr);
+ return ret;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.CResult_boolPeerHandleErrorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Result_boolPeerHandleErrorZ clone() {
number ret = bindings.CResult_boolPeerHandleErrorZ_clone(this.ptr);
Result_boolPeerHandleErrorZ ret_hu_conv = Result_boolPeerHandleErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.RetryAttempts_clone_ptr(this.ptr);
+ return ret;
+ }
+
public RetryAttempts clone() {
number ret = bindings.RetryAttempts_clone(this.ptr);
const ret_hu_conv: RetryAttempts = new RetryAttempts(null, ret);
}
public void set_channel_id(Uint8Array val) {
- bindings.RevokeAndACK_set_channel_id(this.ptr, val);
+ bindings.RevokeAndACK_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public Uint8Array get_per_commitment_secret() {
}
public void set_per_commitment_secret(Uint8Array val) {
- bindings.RevokeAndACK_set_per_commitment_secret(this.ptr, val);
+ bindings.RevokeAndACK_set_per_commitment_secret(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public Uint8Array get_next_per_commitment_point() {
}
public void set_next_per_commitment_point(Uint8Array val) {
- bindings.RevokeAndACK_set_next_per_commitment_point(this.ptr, val);
+ bindings.RevokeAndACK_set_next_per_commitment_point(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public static RevokeAndACK constructor_new(Uint8Array channel_id_arg, Uint8Array per_commitment_secret_arg, Uint8Array next_per_commitment_point_arg) {
- number ret = bindings.RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
+ number ret = bindings.RevokeAndACK_new(InternalUtils.check_arr_len(channel_id_arg, 32), InternalUtils.check_arr_len(per_commitment_secret_arg, 32), InternalUtils.check_arr_len(next_per_commitment_point_arg, 33));
const ret_hu_conv: RevokeAndACK = new RevokeAndACK(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.RevokeAndACK_clone_ptr(this.ptr);
+ return ret;
+ }
+
public RevokeAndACK clone() {
number ret = bindings.RevokeAndACK_clone(this.ptr);
const ret_hu_conv: RevokeAndACK = new RevokeAndACK(null, ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.Route_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Route clone() {
number ret = bindings.Route_clone(this.ptr);
const ret_hu_conv: Route = new Route(null, ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.RouteHint_clone_ptr(this.ptr);
+ return ret;
+ }
+
public RouteHint clone() {
number ret = bindings.RouteHint_clone(this.ptr);
const ret_hu_conv: RouteHint = new RouteHint(null, ret);
}
public void set_src_node_id(Uint8Array val) {
- bindings.RouteHintHop_set_src_node_id(this.ptr, val);
+ bindings.RouteHintHop_set_src_node_id(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public number get_short_channel_id() {
}
public static RouteHintHop constructor_new(Uint8Array src_node_id_arg, number short_channel_id_arg, RoutingFees fees_arg, number cltv_expiry_delta_arg, Option_u64Z htlc_minimum_msat_arg, Option_u64Z htlc_maximum_msat_arg) {
- number ret = bindings.RouteHintHop_new(src_node_id_arg, short_channel_id_arg, fees_arg == null ? 0 : fees_arg.ptr & ~1, cltv_expiry_delta_arg, htlc_minimum_msat_arg.ptr, htlc_maximum_msat_arg.ptr);
+ number ret = bindings.RouteHintHop_new(InternalUtils.check_arr_len(src_node_id_arg, 33), short_channel_id_arg, fees_arg == null ? 0 : fees_arg.ptr & ~1, cltv_expiry_delta_arg, htlc_minimum_msat_arg.ptr, htlc_maximum_msat_arg.ptr);
const ret_hu_conv: RouteHintHop = new RouteHintHop(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.RouteHintHop_clone_ptr(this.ptr);
+ return ret;
+ }
+
public RouteHintHop clone() {
number ret = bindings.RouteHintHop_clone(this.ptr);
const ret_hu_conv: RouteHintHop = new RouteHintHop(null, ret);
}
public void set_pubkey(Uint8Array val) {
- bindings.RouteHop_set_pubkey(this.ptr, val);
+ bindings.RouteHop_set_pubkey(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public NodeFeatures get_node_features() {
}
public static RouteHop constructor_new(Uint8Array pubkey_arg, NodeFeatures node_features_arg, number short_channel_id_arg, ChannelFeatures channel_features_arg, number fee_msat_arg, number cltv_expiry_delta_arg) {
- number ret = bindings.RouteHop_new(pubkey_arg, node_features_arg == null ? 0 : node_features_arg.ptr & ~1, short_channel_id_arg, channel_features_arg == null ? 0 : channel_features_arg.ptr & ~1, fee_msat_arg, cltv_expiry_delta_arg);
+ number ret = bindings.RouteHop_new(InternalUtils.check_arr_len(pubkey_arg, 33), node_features_arg == null ? 0 : node_features_arg.ptr & ~1, short_channel_id_arg, channel_features_arg == null ? 0 : channel_features_arg.ptr & ~1, fee_msat_arg, cltv_expiry_delta_arg);
const ret_hu_conv: RouteHop = new RouteHop(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.RouteHop_clone_ptr(this.ptr);
+ return ret;
+ }
+
public RouteHop clone() {
number ret = bindings.RouteHop_clone(this.ptr);
const ret_hu_conv: RouteHop = new RouteHop(null, ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.RouteParameters_clone_ptr(this.ptr);
+ return ret;
+ }
+
public RouteParameters clone() {
number ret = bindings.RouteParameters_clone(this.ptr);
const ret_hu_conv: RouteParameters = new RouteParameters(null, ret);
Score ret_hu_conv = new Score(null, scorer);
ret_hu_conv.ptrs_to.add(this);
Result_RouteLightningErrorZ ret = arg.find_route(payer, params_hu_conv, first_hops_conv_16_arr, ret_hu_conv);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
held: Router;
}
public Result_RouteLightningErrorZ find_route(Uint8Array payer, RouteParameters params, ChannelDetails[] first_hops, Score scorer) {
- number ret = bindings.Router_find_route(this.ptr, payer, params == null ? 0 : params.ptr & ~1, first_hops != null ? Arrays.stream(first_hops).map(first_hops_conv_16 -> first_hops_conv_16 == null ? 0 : first_hops_conv_16.ptr & ~1).toArray(number[]::new) : null, scorer == null ? 0 : scorer.ptr);
+ number ret = bindings.Router_find_route(this.ptr, InternalUtils.check_arr_len(payer, 33), params == null ? 0 : params.ptr & ~1, first_hops != null ? Arrays.stream(first_hops).map(first_hops_conv_16 -> first_hops_conv_16 == null ? 0 : first_hops_conv_16.ptr & ~1).toArray(number[]::new) : null, scorer == null ? 0 : scorer.ptr);
Result_RouteLightningErrorZ ret_hu_conv = Result_RouteLightningErrorZ.constr_from_ptr(ret);
this.ptrs_to.add(params);
for (ChannelDetails first_hops_conv_16: first_hops) { this.ptrs_to.add(first_hops_conv_16); };
return ret;
}
+ public number clone_ptr() {
+ number ret = bindings.RoutingFees_clone_ptr(this.ptr);
+ return ret;
+ }
+
public RoutingFees clone() {
number ret = bindings.RoutingFees_clone(this.ptr);
const ret_hu_conv: RoutingFees = new RoutingFees(null, ret);
handle_node_announcement (msg: number): number {
const msg_hu_conv: NodeAnnouncement = new NodeAnnouncement(null, msg);
Result_boolLightningErrorZ ret = arg.handle_node_announcement(msg_hu_conv);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
handle_channel_announcement (msg: number): number {
const msg_hu_conv: ChannelAnnouncement = new ChannelAnnouncement(null, msg);
Result_boolLightningErrorZ ret = arg.handle_channel_announcement(msg_hu_conv);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
handle_channel_update (msg: number): number {
const msg_hu_conv: ChannelUpdate = new ChannelUpdate(null, msg);
Result_boolLightningErrorZ ret = arg.handle_channel_update(msg_hu_conv);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
get_next_channel_announcements (starting_point: number, batch_amount: number): number[] {
ThreeTuple_ChannelAnnouncementChannelUpdateChannelUpdateZ[] ret = arg.get_next_channel_announcements(starting_point, batch_amount);
- result: number[] = ret != null ? Arrays.stream(ret).map(ret_conv_59 -> ret_conv_59 != null ? ret_conv_59.ptr : 0).toArray(number[]::new) : null;
+ result: number[] = ret != null ? Arrays.stream(ret).map(ret_conv_59 -> ret_conv_59 == null ? 0 : ret_conv_59.clone_ptr()).toArray(number[]::new) : null;
return result;
},
get_next_node_announcements (starting_point: Uint8Array, batch_amount: number): number[] {
NodeAnnouncement[] ret = arg.get_next_node_announcements(starting_point, batch_amount);
- result: number[] = ret != null ? Arrays.stream(ret).map(ret_conv_18 -> ret_conv_18 == null ? 0 : ret_conv_18.ptr & ~1).toArray(number[]::new) : null;
+ result: number[] = ret != null ? Arrays.stream(ret).map(ret_conv_18 -> ret_conv_18 == null ? 0 : ret_conv_18.clone_ptr()).toArray(number[]::new) : null;
return result;
},
const msg_hu_conv: ReplyChannelRange = new ReplyChannelRange(null, msg);
msg_hu_conv.ptrs_to.add(this);
Result_NoneLightningErrorZ ret = arg.handle_reply_channel_range(their_node_id, msg_hu_conv);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
const msg_hu_conv: ReplyShortChannelIdsEnd = new ReplyShortChannelIdsEnd(null, msg);
msg_hu_conv.ptrs_to.add(this);
Result_NoneLightningErrorZ ret = arg.handle_reply_short_channel_ids_end(their_node_id, msg_hu_conv);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
const msg_hu_conv: QueryChannelRange = new QueryChannelRange(null, msg);
msg_hu_conv.ptrs_to.add(this);
Result_NoneLightningErrorZ ret = arg.handle_query_channel_range(their_node_id, msg_hu_conv);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
const msg_hu_conv: QueryShortChannelIds = new QueryShortChannelIds(null, msg);
msg_hu_conv.ptrs_to.add(this);
Result_NoneLightningErrorZ ret = arg.handle_query_short_channel_ids(their_node_id, msg_hu_conv);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
}
public NodeAnnouncement[] get_next_node_announcements(Uint8Array starting_point, number batch_amount) {
- number[] ret = bindings.RoutingMessageHandler_get_next_node_announcements(this.ptr, starting_point, batch_amount);
+ number[] ret = bindings.RoutingMessageHandler_get_next_node_announcements(this.ptr, InternalUtils.check_arr_len(starting_point, 33), batch_amount);
NodeAnnouncement[] ret_conv_18_arr = new NodeAnnouncement[ret.length];
for (int s = 0; s < ret.length; s++) {
number ret_conv_18 = ret[s];
}
public void sync_routing_table(Uint8Array their_node_id, Init init) {
- bindings.RoutingMessageHandler_sync_routing_table(this.ptr, their_node_id, init == null ? 0 : init.ptr & ~1);
+ bindings.RoutingMessageHandler_sync_routing_table(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), init == null ? 0 : init.ptr & ~1);
this.ptrs_to.add(init);
}
public Result_NoneLightningErrorZ handle_reply_channel_range(Uint8Array their_node_id, ReplyChannelRange msg) {
- number ret = bindings.RoutingMessageHandler_handle_reply_channel_range(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ number ret = bindings.RoutingMessageHandler_handle_reply_channel_range(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
public Result_NoneLightningErrorZ handle_reply_short_channel_ids_end(Uint8Array their_node_id, ReplyShortChannelIdsEnd msg) {
- number ret = bindings.RoutingMessageHandler_handle_reply_short_channel_ids_end(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ number ret = bindings.RoutingMessageHandler_handle_reply_short_channel_ids_end(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
public Result_NoneLightningErrorZ handle_query_channel_range(Uint8Array their_node_id, QueryChannelRange msg) {
- number ret = bindings.RoutingMessageHandler_handle_query_channel_range(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ number ret = bindings.RoutingMessageHandler_handle_query_channel_range(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
public Result_NoneLightningErrorZ handle_query_short_channel_ids(Uint8Array their_node_id, QueryShortChannelIds msg) {
- number ret = bindings.RoutingMessageHandler_handle_query_short_channel_ids(this.ptr, their_node_id, msg == null ? 0 : msg.ptr & ~1);
+ number ret = bindings.RoutingMessageHandler_handle_query_short_channel_ids(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr & ~1);
Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
bindings.Sha256_free(this.ptr);
}
}
+ public number clone_ptr() {
+ number ret = bindings.Sha256_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Sha256 clone() {
number ret = bindings.Sha256_clone(this.ptr);
const ret_hu_conv: Sha256 = new Sha256(null, ret);
}
public void set_channel_id(Uint8Array val) {
- bindings.Shutdown_set_channel_id(this.ptr, val);
+ bindings.Shutdown_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public Uint8Array get_scriptpubkey() {
}
public static Shutdown constructor_new(Uint8Array channel_id_arg, Uint8Array scriptpubkey_arg) {
- number ret = bindings.Shutdown_new(channel_id_arg, scriptpubkey_arg);
+ number ret = bindings.Shutdown_new(InternalUtils.check_arr_len(channel_id_arg, 32), scriptpubkey_arg);
const ret_hu_conv: Shutdown = new Shutdown(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.Shutdown_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Shutdown clone() {
number ret = bindings.Shutdown_clone(this.ptr);
const ret_hu_conv: Shutdown = new Shutdown(null, ret);
bindings.ShutdownScript_free(this.ptr);
}
}
+ public number clone_ptr() {
+ number ret = bindings.ShutdownScript_clone_ptr(this.ptr);
+ return ret;
+ }
+
public ShutdownScript clone() {
number ret = bindings.ShutdownScript_clone(this.ptr);
const ret_hu_conv: ShutdownScript = new ShutdownScript(null, ret);
}
public static ShutdownScript constructor_new_p2wpkh(Uint8Array pubkey_hash) {
- number ret = bindings.ShutdownScript_new_p2wpkh(pubkey_hash);
+ number ret = bindings.ShutdownScript_new_p2wpkh(InternalUtils.check_arr_len(pubkey_hash, 20));
const ret_hu_conv: ShutdownScript = new ShutdownScript(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
public static ShutdownScript constructor_new_p2wsh(Uint8Array script_hash) {
- number ret = bindings.ShutdownScript_new_p2wsh(script_hash);
+ number ret = bindings.ShutdownScript_new_p2wsh(InternalUtils.check_arr_len(script_hash, 32));
const ret_hu_conv: ShutdownScript = new ShutdownScript(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
this.bindings_instance = null;
} else {
// TODO: private constructor instantiation
- super(bindings.LDKSign_new(arg, baseSign, pubkeys == null ? 0 : pubkeys.ptr & ~1));
+ super(bindings.LDKSign_new(arg, baseSign, pubkeys == null ? 0 : pubkeys.clone_ptr()));
this.ptrs_to.push(arg);
this.ptrs_to.push(baseSign);
return ret;
}
+ public number clone_ptr() {
+ number ret = bindings.Sign_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Sign clone() {
number ret = bindings.Sign_clone(this.ptr);
Sign ret_hu_conv = new Sign(null, ret);
this.creation_error = obj.creation_error;
}
}
+ public number clone_ptr() {
+ number ret = bindings.SignOrCreationError_clone_ptr(this.ptr);
+ return ret;
+ }
+
public SignOrCreationError clone() {
number ret = bindings.SignOrCreationError_clone(this.ptr);
SignOrCreationError ret_hu_conv = SignOrCreationError.constr_from_ptr(ret);
return ret;
}
+ public number clone_ptr() {
+ number ret = bindings.SignedRawInvoice_clone_ptr(this.ptr);
+ return ret;
+ }
+
public SignedRawInvoice clone() {
number ret = bindings.SignedRawInvoice_clone(this.ptr);
const ret_hu_conv: SignedRawInvoice = new SignedRawInvoice(null, ret);
return ret;
}
+ public number clone_ptr() {
+ number ret = bindings.SocketDescriptor_clone_ptr(this.ptr);
+ return ret;
+ }
+
public SocketDescriptor clone() {
number ret = bindings.SocketDescriptor_clone(this.ptr);
SocketDescriptor ret_hu_conv = new SocketDescriptor(null, ret);
this.static_payment_output = static_payment_output_hu_conv;
}
}
+ public number clone_ptr() {
+ number ret = bindings.SpendableOutputDescriptor_clone_ptr(this.ptr);
+ return ret;
+ }
+
public SpendableOutputDescriptor clone() {
number ret = bindings.SpendableOutputDescriptor_clone(this.ptr);
SpendableOutputDescriptor ret_hu_conv = SpendableOutputDescriptor.constr_from_ptr(ret);
}
public void set_channel_keys_id(Uint8Array val) {
- bindings.StaticPaymentOutputDescriptor_set_channel_keys_id(this.ptr, val);
+ bindings.StaticPaymentOutputDescriptor_set_channel_keys_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public number get_channel_value_satoshis() {
}
public static StaticPaymentOutputDescriptor constructor_new(OutPoint outpoint_arg, TxOut output_arg, Uint8Array channel_keys_id_arg, number channel_value_satoshis_arg) {
- number ret = bindings.StaticPaymentOutputDescriptor_new(outpoint_arg == null ? 0 : outpoint_arg.ptr & ~1, output_arg.ptr, channel_keys_id_arg, channel_value_satoshis_arg);
+ number ret = bindings.StaticPaymentOutputDescriptor_new(outpoint_arg == null ? 0 : outpoint_arg.ptr & ~1, output_arg.ptr, InternalUtils.check_arr_len(channel_keys_id_arg, 32), channel_value_satoshis_arg);
const ret_hu_conv: StaticPaymentOutputDescriptor = new StaticPaymentOutputDescriptor(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.StaticPaymentOutputDescriptor_clone_ptr(this.ptr);
+ return ret;
+ }
+
public StaticPaymentOutputDescriptor clone() {
number ret = bindings.StaticPaymentOutputDescriptor_clone(this.ptr);
const ret_hu_conv: StaticPaymentOutputDescriptor = new StaticPaymentOutputDescriptor(null, ret);
bindings.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(this.ptr);
}
}
+ public ChannelAnnouncement get_a() {
+ number ret = bindings.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(this.ptr);
+ const ret_hu_conv: ChannelAnnouncement = new ChannelAnnouncement(null, ret);
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+ public ChannelUpdate get_b() {
+ number ret = bindings.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(this.ptr);
+ const ret_hu_conv: ChannelUpdate = new ChannelUpdate(null, ret);
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+ public ChannelUpdate get_c() {
+ number ret = bindings.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(this.ptr);
+ const ret_hu_conv: ChannelUpdate = new ChannelUpdate(null, ret);
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
+ public ThreeTuple_ChannelAnnouncementChannelUpdateChannelUpdateZ clone() {
+ number ret = bindings.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(this.ptr);
+ ThreeTuple_ChannelAnnouncementChannelUpdateChannelUpdateZ ret_hu_conv = new ThreeTuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(null, ret);
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+ public static ThreeTuple_ChannelAnnouncementChannelUpdateChannelUpdateZ constructor_new(ChannelAnnouncement a, ChannelUpdate b, ChannelUpdate c) {
+ number ret = bindings.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a == null ? 0 : a.ptr & ~1, b == null ? 0 : b.ptr & ~1, c == null ? 0 : c.ptr & ~1);
+ ThreeTuple_ChannelAnnouncementChannelUpdateChannelUpdateZ ret_hu_conv = new ThreeTuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(null, ret);
+ ret_hu_conv.ptrs_to.add(ret_hu_conv);
+ return ret_hu_conv;
+ }
+
}
bindings.C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(this.ptr);
}
}
+ public RawInvoice get_a() {
+ number ret = bindings.C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(this.ptr);
+ const ret_hu_conv: RawInvoice = new RawInvoice(null, ret);
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+ public Uint8Array get_b() {
+ Uint8Array ret = bindings.C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(this.ptr);
+ return ret;
+ }
+
+ public InvoiceSignature get_c() {
+ number ret = bindings.C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(this.ptr);
+ const ret_hu_conv: InvoiceSignature = new InvoiceSignature(null, ret);
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
+ public ThreeTuple_RawInvoice_u832InvoiceSignatureZ clone() {
+ number ret = bindings.C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(this.ptr);
+ ThreeTuple_RawInvoice_u832InvoiceSignatureZ ret_hu_conv = new ThreeTuple_RawInvoice_u832InvoiceSignatureZ(null, ret);
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+ public static ThreeTuple_RawInvoice_u832InvoiceSignatureZ constructor_new(RawInvoice a, Uint8Array b, InvoiceSignature c) {
+ number ret = bindings.C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a == null ? 0 : a.ptr & ~1, InternalUtils.check_arr_len(b, 32), c == null ? 0 : c.ptr & ~1);
+ ThreeTuple_RawInvoice_u832InvoiceSignatureZ ret_hu_conv = new ThreeTuple_RawInvoice_u832InvoiceSignatureZ(null, ret);
+ ret_hu_conv.ptrs_to.add(ret_hu_conv);
+ return ret_hu_conv;
+ }
+
}
}
public Uint8Array sign(Uint8Array funding_key, Uint8Array funding_redeemscript, number channel_value_satoshis) {
- Uint8Array ret = bindings.TrustedClosingTransaction_sign(this.ptr, funding_key, funding_redeemscript, channel_value_satoshis);
+ Uint8Array ret = bindings.TrustedClosingTransaction_sign(this.ptr, InternalUtils.check_arr_len(funding_key, 32), funding_redeemscript, channel_value_satoshis);
return ret;
}
}
public Result_CVec_SignatureZNoneZ get_htlc_sigs(Uint8Array htlc_base_key, DirectedChannelTransactionParameters channel_parameters) {
- number ret = bindings.TrustedCommitmentTransaction_get_htlc_sigs(this.ptr, htlc_base_key, channel_parameters == null ? 0 : channel_parameters.ptr & ~1);
+ number ret = bindings.TrustedCommitmentTransaction_get_htlc_sigs(this.ptr, InternalUtils.check_arr_len(htlc_base_key, 32), channel_parameters == null ? 0 : channel_parameters.ptr & ~1);
Result_CVec_SignatureZNoneZ ret_hu_conv = Result_CVec_SignatureZNoneZ.constr_from_ptr(ret);
this.ptrs_to.add(channel_parameters);
return ret_hu_conv;
}
public static TwoTuple_BlockHashChannelManagerZ constructor_new(Uint8Array a, FeeEstimator b_fee_est, Watch b_chain_monitor, BroadcasterInterface b_tx_broadcaster, Logger b_logger, KeysInterface b_keys_manager, UserConfig b_config, ChainParameters b_params) {
- number ret = bindings.C2Tuple_BlockHashChannelManagerZ_new(a, bindings.ChannelManager_new(b_fee_est == null ? 0 : b_fee_est.ptr, b_chain_monitor == null ? 0 : b_chain_monitor.ptr, b_tx_broadcaster == null ? 0 : b_tx_broadcaster.ptr, b_logger == null ? 0 : b_logger.ptr, b_keys_manager == null ? 0 : b_keys_manager.ptr, b_config == null ? 0 : b_config.ptr & ~1, b_params == null ? 0 : b_params.ptr & ~1));
+ number ret = bindings.C2Tuple_BlockHashChannelManagerZ_new(InternalUtils.check_arr_len(a, 32), bindings.ChannelManager_new(b_fee_est == null ? 0 : b_fee_est.ptr, b_chain_monitor == null ? 0 : b_chain_monitor.ptr, b_tx_broadcaster == null ? 0 : b_tx_broadcaster.ptr, b_logger == null ? 0 : b_logger.ptr, b_keys_manager == null ? 0 : b_keys_manager.ptr, b_config == null ? 0 : b_config.ptr & ~1, b_params == null ? 0 : b_params.ptr & ~1));
TwoTuple_BlockHashChannelManagerZ ret_hu_conv = new TwoTuple_BlockHashChannelManagerZ(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
ret_hu_conv.ptrs_to.add(b_fee_est);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.C2Tuple_BlockHashChannelMonitorZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public TwoTuple_BlockHashChannelMonitorZ clone() {
number ret = bindings.C2Tuple_BlockHashChannelMonitorZ_clone(this.ptr);
TwoTuple_BlockHashChannelMonitorZ ret_hu_conv = new TwoTuple_BlockHashChannelMonitorZ(null, ret);
}
public static TwoTuple_BlockHashChannelMonitorZ constructor_new(Uint8Array a, ChannelMonitor b) {
- number ret = bindings.C2Tuple_BlockHashChannelMonitorZ_new(a, b == null ? 0 : b.ptr & ~1);
+ number ret = bindings.C2Tuple_BlockHashChannelMonitorZ_new(InternalUtils.check_arr_len(a, 32), b == null ? 0 : b.ptr & ~1);
TwoTuple_BlockHashChannelMonitorZ ret_hu_conv = new TwoTuple_BlockHashChannelMonitorZ(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
return ret;
}
+ public number clone_ptr() {
+ number ret = bindings.C2Tuple_OutPointScriptZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public TwoTuple_OutPointScriptZ clone() {
number ret = bindings.C2Tuple_OutPointScriptZ_clone(this.ptr);
TwoTuple_OutPointScriptZ ret_hu_conv = new TwoTuple_OutPointScriptZ(null, ret);
return ret;
}
+ public number clone_ptr() {
+ number ret = bindings.C2Tuple_PaymentHashPaymentIdZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public TwoTuple_PaymentHashPaymentIdZ clone() {
number ret = bindings.C2Tuple_PaymentHashPaymentIdZ_clone(this.ptr);
TwoTuple_PaymentHashPaymentIdZ ret_hu_conv = new TwoTuple_PaymentHashPaymentIdZ(null, ret);
}
public static TwoTuple_PaymentHashPaymentIdZ constructor_new(Uint8Array a, Uint8Array b) {
- number ret = bindings.C2Tuple_PaymentHashPaymentIdZ_new(a, b);
+ number ret = bindings.C2Tuple_PaymentHashPaymentIdZ_new(InternalUtils.check_arr_len(a, 32), InternalUtils.check_arr_len(b, 32));
TwoTuple_PaymentHashPaymentIdZ ret_hu_conv = new TwoTuple_PaymentHashPaymentIdZ(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
return ret;
}
+ public number clone_ptr() {
+ number ret = bindings.C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public TwoTuple_PaymentHashPaymentSecretZ clone() {
number ret = bindings.C2Tuple_PaymentHashPaymentSecretZ_clone(this.ptr);
TwoTuple_PaymentHashPaymentSecretZ ret_hu_conv = new TwoTuple_PaymentHashPaymentSecretZ(null, ret);
}
public static TwoTuple_PaymentHashPaymentSecretZ constructor_new(Uint8Array a, Uint8Array b) {
- number ret = bindings.C2Tuple_PaymentHashPaymentSecretZ_new(a, b);
+ number ret = bindings.C2Tuple_PaymentHashPaymentSecretZ_new(InternalUtils.check_arr_len(a, 32), InternalUtils.check_arr_len(b, 32));
TwoTuple_PaymentHashPaymentSecretZ ret_hu_conv = new TwoTuple_PaymentHashPaymentSecretZ(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.C2Tuple_PublicKeyTypeZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public TwoTuple_PublicKeyTypeZ clone() {
number ret = bindings.C2Tuple_PublicKeyTypeZ_clone(this.ptr);
TwoTuple_PublicKeyTypeZ ret_hu_conv = new TwoTuple_PublicKeyTypeZ(null, ret);
}
public static TwoTuple_PublicKeyTypeZ constructor_new(Uint8Array a, Type b) {
- number ret = bindings.C2Tuple_PublicKeyTypeZ_new(a, b == null ? 0 : b.ptr);
+ number ret = bindings.C2Tuple_PublicKeyTypeZ_new(InternalUtils.check_arr_len(a, 33), b == null ? 0 : b.ptr);
TwoTuple_PublicKeyTypeZ ret_hu_conv = new TwoTuple_PublicKeyTypeZ(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
ret_hu_conv.ptrs_to.add(b);
return ret;
}
+ public number clone_ptr() {
+ number ret = bindings.C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public TwoTuple_SignatureCVec_SignatureZZ clone() {
number ret = bindings.C2Tuple_SignatureCVec_SignatureZZ_clone(this.ptr);
TwoTuple_SignatureCVec_SignatureZZ ret_hu_conv = new TwoTuple_SignatureCVec_SignatureZZ(null, ret);
}
public static TwoTuple_SignatureCVec_SignatureZZ constructor_new(Uint8Array a, Uint8Array[] b) {
- number ret = bindings.C2Tuple_SignatureCVec_SignatureZZ_new(a, b);
+ number ret = bindings.C2Tuple_SignatureCVec_SignatureZZ_new(InternalUtils.check_arr_len(a, 64), b != null ? Arrays.stream(b).map(b_conv_12 -> InternalUtils.check_arr_len(b_conv_12, 64)).toArray(Uint8Array[]::new) : null);
TwoTuple_SignatureCVec_SignatureZZ ret_hu_conv = new TwoTuple_SignatureCVec_SignatureZZ(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
return ret_conv_21_arr;
}
+ public number clone_ptr() {
+ number ret = bindings.C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public TwoTuple_TxidCVec_C2Tuple_u32ScriptZZZ clone() {
number ret = bindings.C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(this.ptr);
TwoTuple_TxidCVec_C2Tuple_u32ScriptZZZ ret_hu_conv = new TwoTuple_TxidCVec_C2Tuple_u32ScriptZZZ(null, ret);
}
public static TwoTuple_TxidCVec_C2Tuple_u32ScriptZZZ constructor_new(Uint8Array a, TwoTuple_u32ScriptZ[] b) {
- number ret = bindings.C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a, b != null ? Arrays.stream(b).map(b_conv_21 -> b_conv_21 != null ? b_conv_21.ptr : 0).toArray(number[]::new) : null);
+ number ret = bindings.C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(InternalUtils.check_arr_len(a, 32), b != null ? Arrays.stream(b).map(b_conv_21 -> b_conv_21 != null ? b_conv_21.ptr : 0).toArray(number[]::new) : null);
TwoTuple_TxidCVec_C2Tuple_u32ScriptZZZ ret_hu_conv = new TwoTuple_TxidCVec_C2Tuple_u32ScriptZZZ(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
return ret_conv_20_arr;
}
+ public number clone_ptr() {
+ number ret = bindings.C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ clone() {
number ret = bindings.C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(this.ptr);
TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ ret_hu_conv = new TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ(null, ret);
}
public static TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ constructor_new(Uint8Array a, TwoTuple_u32TxOutZ[] b) {
- number ret = bindings.C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a, b != null ? Arrays.stream(b).map(b_conv_20 -> b_conv_20 != null ? b_conv_20.ptr : 0).toArray(number[]::new) : null);
+ number ret = bindings.C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(InternalUtils.check_arr_len(a, 32), b != null ? Arrays.stream(b).map(b_conv_20 -> b_conv_20 != null ? b_conv_20.ptr : 0).toArray(number[]::new) : null);
TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ ret_hu_conv = new TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
return ret;
}
+ public number clone_ptr() {
+ number ret = bindings.C2Tuple_u32ScriptZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public TwoTuple_u32ScriptZ clone() {
number ret = bindings.C2Tuple_u32ScriptZ_clone(this.ptr);
TwoTuple_u32ScriptZ ret_hu_conv = new TwoTuple_u32ScriptZ(null, ret);
return ret_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.C2Tuple_u32TxOutZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public TwoTuple_u32TxOutZ clone() {
number ret = bindings.C2Tuple_u32TxOutZ_clone(this.ptr);
TwoTuple_u32TxOutZ ret_hu_conv = new TwoTuple_u32TxOutZ(null, ret);
return ret;
}
+ public number clone_ptr() {
+ number ret = bindings.C2Tuple_usizeTransactionZ_clone_ptr(this.ptr);
+ return ret;
+ }
+
public TwoTuple_usizeTransactionZ clone() {
number ret = bindings.C2Tuple_usizeTransactionZ_clone(this.ptr);
TwoTuple_usizeTransactionZ ret_hu_conv = new TwoTuple_usizeTransactionZ(null, ret);
}
public void set_per_commitment_point(Uint8Array val) {
- bindings.TxCreationKeys_set_per_commitment_point(this.ptr, val);
+ bindings.TxCreationKeys_set_per_commitment_point(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_revocation_key() {
}
public void set_revocation_key(Uint8Array val) {
- bindings.TxCreationKeys_set_revocation_key(this.ptr, val);
+ bindings.TxCreationKeys_set_revocation_key(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_broadcaster_htlc_key() {
}
public void set_broadcaster_htlc_key(Uint8Array val) {
- bindings.TxCreationKeys_set_broadcaster_htlc_key(this.ptr, val);
+ bindings.TxCreationKeys_set_broadcaster_htlc_key(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_countersignatory_htlc_key() {
}
public void set_countersignatory_htlc_key(Uint8Array val) {
- bindings.TxCreationKeys_set_countersignatory_htlc_key(this.ptr, val);
+ bindings.TxCreationKeys_set_countersignatory_htlc_key(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_broadcaster_delayed_payment_key() {
}
public void set_broadcaster_delayed_payment_key(Uint8Array val) {
- bindings.TxCreationKeys_set_broadcaster_delayed_payment_key(this.ptr, val);
+ bindings.TxCreationKeys_set_broadcaster_delayed_payment_key(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public static TxCreationKeys constructor_new(Uint8Array per_commitment_point_arg, Uint8Array revocation_key_arg, Uint8Array broadcaster_htlc_key_arg, Uint8Array countersignatory_htlc_key_arg, Uint8Array broadcaster_delayed_payment_key_arg) {
- number ret = bindings.TxCreationKeys_new(per_commitment_point_arg, revocation_key_arg, broadcaster_htlc_key_arg, countersignatory_htlc_key_arg, broadcaster_delayed_payment_key_arg);
+ number ret = bindings.TxCreationKeys_new(InternalUtils.check_arr_len(per_commitment_point_arg, 33), InternalUtils.check_arr_len(revocation_key_arg, 33), InternalUtils.check_arr_len(broadcaster_htlc_key_arg, 33), InternalUtils.check_arr_len(countersignatory_htlc_key_arg, 33), InternalUtils.check_arr_len(broadcaster_delayed_payment_key_arg, 33));
const ret_hu_conv: TxCreationKeys = new TxCreationKeys(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.TxCreationKeys_clone_ptr(this.ptr);
+ return ret;
+ }
+
public TxCreationKeys clone() {
number ret = bindings.TxCreationKeys_clone(this.ptr);
const ret_hu_conv: TxCreationKeys = new TxCreationKeys(null, ret);
}
public static Result_TxCreationKeysErrorZ constructor_derive_new(Uint8Array per_commitment_point, Uint8Array broadcaster_delayed_payment_base, Uint8Array broadcaster_htlc_base, Uint8Array countersignatory_revocation_base, Uint8Array countersignatory_htlc_base) {
- number ret = bindings.TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
+ number ret = bindings.TxCreationKeys_derive_new(InternalUtils.check_arr_len(per_commitment_point, 33), InternalUtils.check_arr_len(broadcaster_delayed_payment_base, 33), InternalUtils.check_arr_len(broadcaster_htlc_base, 33), InternalUtils.check_arr_len(countersignatory_revocation_base, 33), InternalUtils.check_arr_len(countersignatory_htlc_base, 33));
Result_TxCreationKeysErrorZ ret_hu_conv = Result_TxCreationKeysErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
public static Result_TxCreationKeysErrorZ constructor_from_channel_static_keys(Uint8Array per_commitment_point, ChannelPublicKeys broadcaster_keys, ChannelPublicKeys countersignatory_keys) {
- number ret = bindings.TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys == null ? 0 : broadcaster_keys.ptr & ~1, countersignatory_keys == null ? 0 : countersignatory_keys.ptr & ~1);
+ number ret = bindings.TxCreationKeys_from_channel_static_keys(InternalUtils.check_arr_len(per_commitment_point, 33), broadcaster_keys == null ? 0 : broadcaster_keys.ptr & ~1, countersignatory_keys == null ? 0 : countersignatory_keys.ptr & ~1);
Result_TxCreationKeysErrorZ ret_hu_conv = Result_TxCreationKeysErrorZ.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(broadcaster_keys);
ret_hu_conv.ptrs_to.add(countersignatory_keys);
return ret;
}
+ public number clone_ptr() {
+ number ret = bindings.Type_clone_ptr(this.ptr);
+ return ret;
+ }
+
public Type clone() {
number ret = bindings.Type_clone(this.ptr);
Type ret_hu_conv = new Type(null, ret);
}
public void set_chain_hash(Uint8Array val) {
- bindings.UnsignedChannelAnnouncement_set_chain_hash(this.ptr, val);
+ bindings.UnsignedChannelAnnouncement_set_chain_hash(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public number get_short_channel_id() {
}
public void set_node_id_1(Uint8Array val) {
- bindings.UnsignedChannelAnnouncement_set_node_id_1(this.ptr, val);
+ bindings.UnsignedChannelAnnouncement_set_node_id_1(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_node_id_2() {
}
public void set_node_id_2(Uint8Array val) {
- bindings.UnsignedChannelAnnouncement_set_node_id_2(this.ptr, val);
+ bindings.UnsignedChannelAnnouncement_set_node_id_2(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_bitcoin_key_1() {
}
public void set_bitcoin_key_1(Uint8Array val) {
- bindings.UnsignedChannelAnnouncement_set_bitcoin_key_1(this.ptr, val);
+ bindings.UnsignedChannelAnnouncement_set_bitcoin_key_1(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_bitcoin_key_2() {
}
public void set_bitcoin_key_2(Uint8Array val) {
- bindings.UnsignedChannelAnnouncement_set_bitcoin_key_2(this.ptr, val);
+ bindings.UnsignedChannelAnnouncement_set_bitcoin_key_2(this.ptr, InternalUtils.check_arr_len(val, 33));
+ }
+
+ public number clone_ptr() {
+ number ret = bindings.UnsignedChannelAnnouncement_clone_ptr(this.ptr);
+ return ret;
}
public UnsignedChannelAnnouncement clone() {
}
public void set_chain_hash(Uint8Array val) {
- bindings.UnsignedChannelUpdate_set_chain_hash(this.ptr, val);
+ bindings.UnsignedChannelUpdate_set_chain_hash(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public number get_short_channel_id() {
bindings.UnsignedChannelUpdate_set_fee_proportional_millionths(this.ptr, val);
}
+ public number clone_ptr() {
+ number ret = bindings.UnsignedChannelUpdate_clone_ptr(this.ptr);
+ return ret;
+ }
+
public UnsignedChannelUpdate clone() {
number ret = bindings.UnsignedChannelUpdate_clone(this.ptr);
const ret_hu_conv: UnsignedChannelUpdate = new UnsignedChannelUpdate(null, ret);
}
public void set_node_id(Uint8Array val) {
- bindings.UnsignedNodeAnnouncement_set_node_id(this.ptr, val);
+ bindings.UnsignedNodeAnnouncement_set_node_id(this.ptr, InternalUtils.check_arr_len(val, 33));
}
public Uint8Array get_rgb() {
}
public void set_rgb(Uint8Array val) {
- bindings.UnsignedNodeAnnouncement_set_rgb(this.ptr, val);
+ bindings.UnsignedNodeAnnouncement_set_rgb(this.ptr, InternalUtils.check_arr_len(val, 3));
}
public Uint8Array get_alias() {
}
public void set_alias(Uint8Array val) {
- bindings.UnsignedNodeAnnouncement_set_alias(this.ptr, val);
+ bindings.UnsignedNodeAnnouncement_set_alias(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public void set_addresses(NetAddress[] val) {
bindings.UnsignedNodeAnnouncement_set_addresses(this.ptr, val != null ? Arrays.stream(val).map(val_conv_12 -> val_conv_12.ptr).toArray(number[]::new) : null);
}
+ public number clone_ptr() {
+ number ret = bindings.UnsignedNodeAnnouncement_clone_ptr(this.ptr);
+ return ret;
+ }
+
public UnsignedNodeAnnouncement clone() {
number ret = bindings.UnsignedNodeAnnouncement_clone(this.ptr);
const ret_hu_conv: UnsignedNodeAnnouncement = new UnsignedNodeAnnouncement(null, ret);
}
public void set_channel_id(Uint8Array val) {
- bindings.UpdateAddHTLC_set_channel_id(this.ptr, val);
+ bindings.UpdateAddHTLC_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public number get_htlc_id() {
}
public void set_payment_hash(Uint8Array val) {
- bindings.UpdateAddHTLC_set_payment_hash(this.ptr, val);
+ bindings.UpdateAddHTLC_set_payment_hash(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public number get_cltv_expiry() {
bindings.UpdateAddHTLC_set_cltv_expiry(this.ptr, val);
}
+ public number clone_ptr() {
+ number ret = bindings.UpdateAddHTLC_clone_ptr(this.ptr);
+ return ret;
+ }
+
public UpdateAddHTLC clone() {
number ret = bindings.UpdateAddHTLC_clone(this.ptr);
const ret_hu_conv: UpdateAddHTLC = new UpdateAddHTLC(null, ret);
}
public void set_channel_id(Uint8Array val) {
- bindings.UpdateFailHTLC_set_channel_id(this.ptr, val);
+ bindings.UpdateFailHTLC_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public number get_htlc_id() {
bindings.UpdateFailHTLC_set_htlc_id(this.ptr, val);
}
+ public number clone_ptr() {
+ number ret = bindings.UpdateFailHTLC_clone_ptr(this.ptr);
+ return ret;
+ }
+
public UpdateFailHTLC clone() {
number ret = bindings.UpdateFailHTLC_clone(this.ptr);
const ret_hu_conv: UpdateFailHTLC = new UpdateFailHTLC(null, ret);
}
public void set_channel_id(Uint8Array val) {
- bindings.UpdateFailMalformedHTLC_set_channel_id(this.ptr, val);
+ bindings.UpdateFailMalformedHTLC_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public number get_htlc_id() {
bindings.UpdateFailMalformedHTLC_set_failure_code(this.ptr, val);
}
+ public number clone_ptr() {
+ number ret = bindings.UpdateFailMalformedHTLC_clone_ptr(this.ptr);
+ return ret;
+ }
+
public UpdateFailMalformedHTLC clone() {
number ret = bindings.UpdateFailMalformedHTLC_clone(this.ptr);
const ret_hu_conv: UpdateFailMalformedHTLC = new UpdateFailMalformedHTLC(null, ret);
}
public void set_channel_id(Uint8Array val) {
- bindings.UpdateFee_set_channel_id(this.ptr, val);
+ bindings.UpdateFee_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public number get_feerate_per_kw() {
}
public static UpdateFee constructor_new(Uint8Array channel_id_arg, number feerate_per_kw_arg) {
- number ret = bindings.UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
+ number ret = bindings.UpdateFee_new(InternalUtils.check_arr_len(channel_id_arg, 32), feerate_per_kw_arg);
const ret_hu_conv: UpdateFee = new UpdateFee(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.UpdateFee_clone_ptr(this.ptr);
+ return ret;
+ }
+
public UpdateFee clone() {
number ret = bindings.UpdateFee_clone(this.ptr);
const ret_hu_conv: UpdateFee = new UpdateFee(null, ret);
}
public void set_channel_id(Uint8Array val) {
- bindings.UpdateFulfillHTLC_set_channel_id(this.ptr, val);
+ bindings.UpdateFulfillHTLC_set_channel_id(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public number get_htlc_id() {
}
public void set_payment_preimage(Uint8Array val) {
- bindings.UpdateFulfillHTLC_set_payment_preimage(this.ptr, val);
+ bindings.UpdateFulfillHTLC_set_payment_preimage(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public static UpdateFulfillHTLC constructor_new(Uint8Array channel_id_arg, number htlc_id_arg, Uint8Array payment_preimage_arg) {
- number ret = bindings.UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
+ number ret = bindings.UpdateFulfillHTLC_new(InternalUtils.check_arr_len(channel_id_arg, 32), htlc_id_arg, InternalUtils.check_arr_len(payment_preimage_arg, 32));
const ret_hu_conv: UpdateFulfillHTLC = new UpdateFulfillHTLC(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.UpdateFulfillHTLC_clone_ptr(this.ptr);
+ return ret;
+ }
+
public UpdateFulfillHTLC clone() {
number ret = bindings.UpdateFulfillHTLC_clone(this.ptr);
const ret_hu_conv: UpdateFulfillHTLC = new UpdateFulfillHTLC(null, ret);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.UserConfig_clone_ptr(this.ptr);
+ return ret;
+ }
+
public UserConfig clone() {
number ret = bindings.UserConfig_clone(this.ptr);
const ret_hu_conv: UserConfig = new UserConfig(null, ret);
+ public static Result_COption_ClosureReasonZDecodeErrorZ constructor_ClosureReason_read(Uint8Array ser) {
+ number ret = bindings.ClosureReason_read(ser);
+ Result_COption_ClosureReasonZDecodeErrorZ ret_hu_conv = Result_COption_ClosureReasonZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ public static Result_COption_EventZDecodeErrorZ constructor_Event_read(Uint8Array ser) {
+ number ret = bindings.Event_read(ser);
+ Result_COption_EventZDecodeErrorZ ret_hu_conv = Result_COption_EventZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
public static Result_StringErrorZ constructor_sign(Uint8Array msg, Uint8Array sk) {
- number ret = bindings.sign(msg, sk);
+ number ret = bindings.sign(msg, InternalUtils.check_arr_len(sk, 32));
Result_StringErrorZ ret_hu_conv = Result_StringErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
}
public static boolean constructor_verify(Uint8Array msg, String sig, Uint8Array pk) {
- boolean ret = bindings.verify(msg, sig, pk);
+ boolean ret = bindings.verify(msg, sig, InternalUtils.check_arr_len(pk, 33));
return ret;
}
+ public static Result_COption_MonitorEventZDecodeErrorZ constructor_MonitorEvent_read(Uint8Array ser) {
+ number ret = bindings.MonitorEvent_read(ser);
+ Result_COption_MonitorEventZDecodeErrorZ ret_hu_conv = Result_COption_MonitorEventZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
public static Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ constructor_C2Tuple_BlockHashChannelMonitorZ_read(Uint8Array ser, KeysInterface arg) {
number ret = bindings.C2Tuple_BlockHashChannelMonitorZ_read(ser, arg == null ? 0 : arg.ptr);
Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ ret_hu_conv = Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ.constr_from_ptr(ret);
}
public static Uint8Array constructor_build_commitment_secret(Uint8Array commitment_seed, number idx) {
- Uint8Array ret = bindings.build_commitment_secret(commitment_seed, idx);
+ Uint8Array ret = bindings.build_commitment_secret(InternalUtils.check_arr_len(commitment_seed, 32), idx);
return ret;
}
}
public static Result_SecretKeyErrorZ constructor_derive_private_key(Uint8Array per_commitment_point, Uint8Array base_secret) {
- number ret = bindings.derive_private_key(per_commitment_point, base_secret);
+ number ret = bindings.derive_private_key(InternalUtils.check_arr_len(per_commitment_point, 33), InternalUtils.check_arr_len(base_secret, 32));
Result_SecretKeyErrorZ ret_hu_conv = Result_SecretKeyErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
public static Result_PublicKeyErrorZ constructor_derive_public_key(Uint8Array per_commitment_point, Uint8Array base_point) {
- number ret = bindings.derive_public_key(per_commitment_point, base_point);
+ number ret = bindings.derive_public_key(InternalUtils.check_arr_len(per_commitment_point, 33), InternalUtils.check_arr_len(base_point, 33));
Result_PublicKeyErrorZ ret_hu_conv = Result_PublicKeyErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
public static Result_SecretKeyErrorZ constructor_derive_private_revocation_key(Uint8Array per_commitment_secret, Uint8Array countersignatory_revocation_base_secret) {
- number ret = bindings.derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
+ number ret = bindings.derive_private_revocation_key(InternalUtils.check_arr_len(per_commitment_secret, 32), InternalUtils.check_arr_len(countersignatory_revocation_base_secret, 32));
Result_SecretKeyErrorZ ret_hu_conv = Result_SecretKeyErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
public static Result_PublicKeyErrorZ constructor_derive_public_revocation_key(Uint8Array per_commitment_point, Uint8Array countersignatory_revocation_base_point) {
- number ret = bindings.derive_public_revocation_key(per_commitment_point, countersignatory_revocation_base_point);
+ number ret = bindings.derive_public_revocation_key(InternalUtils.check_arr_len(per_commitment_point, 33), InternalUtils.check_arr_len(countersignatory_revocation_base_point, 33));
Result_PublicKeyErrorZ ret_hu_conv = Result_PublicKeyErrorZ.constr_from_ptr(ret);
return ret_hu_conv;
}
public static Uint8Array constructor_get_revokeable_redeemscript(Uint8Array revocation_key, number contest_delay, Uint8Array broadcaster_delayed_payment_key) {
- Uint8Array ret = bindings.get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
+ Uint8Array ret = bindings.get_revokeable_redeemscript(InternalUtils.check_arr_len(revocation_key, 33), contest_delay, InternalUtils.check_arr_len(broadcaster_delayed_payment_key, 33));
return ret;
}
}
public static Uint8Array constructor_make_funding_redeemscript(Uint8Array broadcaster, Uint8Array countersignatory) {
- Uint8Array ret = bindings.make_funding_redeemscript(broadcaster, countersignatory);
+ Uint8Array ret = bindings.make_funding_redeemscript(InternalUtils.check_arr_len(broadcaster, 33), InternalUtils.check_arr_len(countersignatory, 33));
return ret;
}
public static Uint8Array constructor_build_htlc_transaction(Uint8Array commitment_txid, number feerate_per_kw, number contest_delay, HTLCOutputInCommitment htlc, Uint8Array broadcaster_delayed_payment_key, Uint8Array revocation_key) {
- Uint8Array ret = bindings.build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc == null ? 0 : htlc.ptr & ~1, broadcaster_delayed_payment_key, revocation_key);
+ Uint8Array ret = bindings.build_htlc_transaction(InternalUtils.check_arr_len(commitment_txid, 32), feerate_per_kw, contest_delay, htlc == null ? 0 : htlc.ptr & ~1, InternalUtils.check_arr_len(broadcaster_delayed_payment_key, 33), InternalUtils.check_arr_len(revocation_key, 33));
// this.ptrs_to.add(htlc);
return ret;
}
public static number constructor_get_commitment_transaction_number_obscure_factor(Uint8Array broadcaster_payment_basepoint, Uint8Array countersignatory_payment_basepoint, boolean outbound_from_broadcaster) {
- number ret = bindings.get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
+ number ret = bindings.get_commitment_transaction_number_obscure_factor(InternalUtils.check_arr_len(broadcaster_payment_basepoint, 33), InternalUtils.check_arr_len(countersignatory_payment_basepoint, 33), outbound_from_broadcaster);
return ret;
}
+ public static Result_COption_NetworkUpdateZDecodeErrorZ constructor_NetworkUpdate_read(Uint8Array ser) {
+ number ret = bindings.NetworkUpdate_read(ser);
+ Result_COption_NetworkUpdateZDecodeErrorZ ret_hu_conv = Result_COption_NetworkUpdateZDecodeErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
public static Result_RouteLightningErrorZ constructor_find_route(Uint8Array our_node_pubkey, RouteParameters params, NetworkGraph network, ChannelDetails[] first_hops, Logger logger, Score scorer) {
- number ret = bindings.find_route(our_node_pubkey, params == null ? 0 : params.ptr & ~1, network == null ? 0 : network.ptr & ~1, first_hops != null ? Arrays.stream(first_hops).map(first_hops_conv_16 -> first_hops_conv_16 == null ? 0 : first_hops_conv_16.ptr & ~1).toArray(number[]::new) : null, logger == null ? 0 : logger.ptr, scorer == null ? 0 : scorer.ptr);
+ number ret = bindings.find_route(InternalUtils.check_arr_len(our_node_pubkey, 33), params == null ? 0 : params.ptr & ~1, network == null ? 0 : network.ptr & ~1, first_hops != null ? Arrays.stream(first_hops).map(first_hops_conv_16 -> first_hops_conv_16 == null ? 0 : first_hops_conv_16.ptr & ~1).toArray(number[]::new) : null, logger == null ? 0 : logger.ptr, scorer == null ? 0 : scorer.ptr);
Result_RouteLightningErrorZ ret_hu_conv = Result_RouteLightningErrorZ.constr_from_ptr(ret);
ret_hu_conv.ptrs_to.add(params);
ret_hu_conv.ptrs_to.add(network);
const monitor_hu_conv: ChannelMonitor = new ChannelMonitor(null, monitor);
monitor_hu_conv.ptrs_to.add(this);
Result_NoneChannelMonitorUpdateErrZ ret = arg.watch_channel(funding_txo_hu_conv, monitor_hu_conv);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
const update_hu_conv: ChannelMonitorUpdate = new ChannelMonitorUpdate(null, update);
update_hu_conv.ptrs_to.add(this);
Result_NoneChannelMonitorUpdateErrZ ret = arg.update_channel(funding_txo_hu_conv, update_hu_conv);
- result: number = ret != null ? ret.ptr : 0;
+ result: number = ret == null ? 0 : ret.clone_ptr();
return result;
},
release_pending_monitor_events (): number[] {
MonitorEvent[] ret = arg.release_pending_monitor_events();
- result: number[] = ret != null ? Arrays.stream(ret).map(ret_conv_14 -> ret_conv_14.ptr).toArray(number[]::new) : null;
+ result: number[] = ret != null ? Arrays.stream(ret).map(ret_conv_14 -> ret_conv_14 == null ? 0 : ret_conv_14.clone_ptr()).toArray(number[]::new) : null;
return result;
},
}
public void set_block_hash(Uint8Array val) {
- bindings.WatchedOutput_set_block_hash(this.ptr, val);
+ bindings.WatchedOutput_set_block_hash(this.ptr, InternalUtils.check_arr_len(val, 32));
}
public OutPoint get_outpoint() {
}
public static WatchedOutput constructor_new(Uint8Array block_hash_arg, OutPoint outpoint_arg, Uint8Array script_pubkey_arg) {
- number ret = bindings.WatchedOutput_new(block_hash_arg, outpoint_arg == null ? 0 : outpoint_arg.ptr & ~1, script_pubkey_arg);
+ number ret = bindings.WatchedOutput_new(InternalUtils.check_arr_len(block_hash_arg, 32), outpoint_arg == null ? 0 : outpoint_arg.ptr & ~1, script_pubkey_arg);
const ret_hu_conv: WatchedOutput = new WatchedOutput(null, ret);
ret_hu_conv.ptrs_to.add(ret_hu_conv);
return ret_hu_conv;
}
+ public number clone_ptr() {
+ number ret = bindings.WatchedOutput_clone_ptr(this.ptr);
+ return ret;
+ }
+
public WatchedOutput clone() {
number ret = bindings.WatchedOutput_clone(this.ptr);
const ret_hu_conv: WatchedOutput = new WatchedOutput(null, ret);
#define DO_ASSERT(a) (void)(a)
#define CHECK(a)
#define CHECK_ACCESS(p)
+#define CHECK_INNER_FIELD_ACCESS_OR_NULL(v)
"""
else:
self.c_file_pfx = self.c_file_pfx + """
}
}
}
+#define CHECK_INNER_FIELD_ACCESS_OR_NULL(v) \\
+ if (v.is_owned && v.inner != NULL) { \\
+ const void *p = __unmangle_inner_ptr(v.inner); \\
+ if (p != NULL) { \\
+ CHECK_ACCESS(p); \\
+ } \\
+ }
void* __wrap_malloc(size_t len) {
void* res = __real_malloc(len);
out_typescript_enum_fields = ""
- for var in variants:
+ for var, var_docs in variants:
out_c = out_c + "\t\tcase %d: return %s;\n" % (ord_v, var)
ord_v = ord_v + 1
+ if var_docs is not None:
+ out_typescript_enum_fields += f"/**\n * {var_docs}\n */\n"
out_typescript_enum_fields += f"{var},\n\t\t\t\t"
out_c = out_c + "\t}\n"
out_c = out_c + "\tabort();\n"
out_c = out_c + "static inline int32_t LDK" + struct_name + "_to_js(LDK" + struct_name + " val) {\n"
out_c = out_c + "\tswitch (val) {\n"
ord_v = 0
- for var in variants:
+ for var, _ in variants:
out_c = out_c + "\t\tcase " + var + ": return %d;\n" % ord_v
ord_v = ord_v + 1
out_c = out_c + "\t\tdefault: abort();\n"
projects / ldk-java / commitdiff