self.bindings_header = """
import * as version from './version.mjs';
+import { UInt5, WitnessVersion } from './structs/CommonBase.mjs';
const imports: any = {};
imports.env = {};
var js_objs: Array<WeakRef<object>> = [];
var js_invoke: Function;
+var getRandomValues: Function;
imports.wasi_snapshot_preview1 = {
- "fd_write": (fd: number, iovec_array_ptr: number, iovec_array_len: number) => {
+ "fd_write": (fd: number, iovec_array_ptr: number, iovec_array_len: number, bytes_written_ptr: number) => {
// This should generally only be used to print panic messages
- console.log("FD_WRITE to " + fd + " in " + iovec_array_len + " chunks.");
const ptr_len_view = new Uint32Array(wasm.memory.buffer, iovec_array_ptr, iovec_array_len * 2);
+ var bytes_written = 0;
for (var i = 0; i < iovec_array_len; i++) {
const bytes_view = new Uint8Array(wasm.memory.buffer, ptr_len_view[i*2], ptr_len_view[i*2+1]);
- console.log(String.fromCharCode(...bytes_view));
+ console.log("[fd " + fd + "]: " + String.fromCharCode(...bytes_view));
+ bytes_written += ptr_len_view[i*2+1];
}
+ const written_view = new Uint32Array(wasm.memory.buffer, bytes_written_ptr, 1);
+ written_view[0] = bytes_written;
return 0;
},
"fd_close": (_fd: number) => {
},
"random_get": (buf_ptr: number, buf_len: number) => {
const buf = new Uint8Array(wasm.memory.buffer, buf_ptr, buf_len);
- crypto.getRandomValues(buf);
+ getRandomValues(buf);
return 0;
},
"environ_sizes_get": (environ_var_count_ptr: number, environ_len_ptr: number) => {
// This is called before fd_write to format + print panic messages
- console.log("wasi_snapshot_preview1:environ_sizes_get");
const out_count_view = new Uint32Array(wasm.memory.buffer, environ_var_count_ptr, 1);
- out_count_view[0] = 1;
+ out_count_view[0] = 0;
const out_len_view = new Uint32Array(wasm.memory.buffer, environ_len_ptr, 1);
- out_len_view[0] = "RUST_BACKTRACE=1".length + 1; // Note that string must be NULL-terminated
+ out_len_view[0] = 0;
return 0;
},
"environ_get": (environ_ptr: number, environ_buf_ptr: number) => {
- // This is called before fd_write to format + print panic messages
+ // This is called before fd_write to format + print panic messages,
+ // but only if we have variables in environ_sizes_get, so shouldn't ever actually happen!
console.log("wasi_snapshot_preview1:environ_get");
- const out_ptrs = new Uint32Array(wasm.memory.buffer, environ_ptr, 2);
- out_ptrs[0] = environ_buf_ptr;
- out_ptrs[1] = "RUST_BACKTRACE=1".length;
- const out_environ = new Uint8Array(wasm.memory.buffer, environ_buf_ptr, out_ptrs[1]);
- for (var i = 0; i < out_ptrs[1]; i++) { out_environ[i] = "RUST_BACKTRACE=1".codePointAt(i); }
- out_environ[out_ptrs[1]] = 0;
- return 0;
+ return 58; // Note supported - we said there were 0 environment entries!
},
"proc_exit" : () => {
console.log("wasi_snapshot_preview1:proc_exit");
var wasm: any = null;
let isWasmInitialized: boolean = false;
-"""
- if target == Target.NODEJS:
- self.bindings_header += """import * as fs from 'fs';
-import { webcrypto as crypto } from 'crypto';
-/* @internal */
-export async function initializeWasm(path: string) {
- const source = fs.readFileSync(path);
- imports.env["js_invoke_function"] = js_invoke;
- const { instance: wasmInstance } = await WebAssembly.instantiate(source, imports);"""
- else:
- self.bindings_header += """
-/* @internal */
-export async function initializeWasm(uri: string) {
- const stream = fetch(uri);
- imports.env["js_invoke_function"] = js_invoke;
- const { instance: wasmInstance } = await WebAssembly.instantiateStreaming(stream, imports);"""
+async function finishInitializeWasm(wasmInstance: WebAssembly.Instance) {
+ if (typeof crypto === "undefined") {
+ var crypto_import = (await import('crypto')).webcrypto;
+ getRandomValues = crypto_import.getRandomValues.bind(crypto_import);
+ } else {
+ getRandomValues = crypto.getRandomValues.bind(crypto);
+ }
- self.bindings_header += """
wasm = wasmInstance.exports;
if (!wasm.test_bigint_pass_deadbeef0badf00d(BigInt("0xdeadbeef0badf00d"))) {
throw new Error(\"Currently need BigInt-as-u64 support, try ----experimental-wasm-bigint");
}
if (decodeString(wasm.TS_get_lib_version_string()) !== version.get_ldk_java_bindings_version())
- throw new Error(\"Compiled LDK library and LDK class failes do not match\");
+ throw new Error(\"Compiled LDK library and LDK class files do not match\");
// Fetching the LDK versions from C also checks that the header and binaries match
- if (wasm.TS_get_ldk_c_bindings_version() == 0)
+ const c_bindings_ver: number = wasm.TS_get_ldk_c_bindings_version();
+ const ldk_ver: number = wasm.TS_get_ldk_version();
+ if (c_bindings_ver == 0)
throw new Error(\"LDK version did not match the header we built against\");
- if (wasm.TS_get_ldk_version() == 0)
+ if (ldk_ver == 0)
throw new Error(\"LDK C bindings version did not match the header we built against\");
- const c_bindings_version: string = decodeString(wasm.TS_get_ldk_c_bindings_version());
- const ldk_version: string = decodeString(wasm.TS_get_ldk_version());
+ const c_bindings_version: string = decodeString(c_bindings_ver)
+ const ldk_version: string = decodeString(ldk_ver);
console.log(\"Loaded LDK-Java Bindings with LDK \" + ldk_version + \" and LDK-C-Bindings \" + c_bindings_version);
isWasmInitialized = true;
-};
+}
+
+const fn_list = ["uuuuuu", "buuuuu", "bbuuuu", "bbbuuu", "bbbbuu",
+ "bbbbbb", "ubuubu", "ubuuuu", "ubbuuu", "uubuuu", "uububu"];
+
+/* @internal */
+export async function initializeWasmFromUint8Array(wasmBinary: Uint8Array) {
+ for (const fn of fn_list) { imports.env["js_invoke_function_" + fn] = js_invoke; }
+ const { instance: wasmInstance } = await WebAssembly.instantiate(wasmBinary, imports);
+ await finishInitializeWasm(wasmInstance);
+}
+/* @internal */
+export async function initializeWasmFetch(uri: string) {
+ for (const fn of fn_list) { imports.env["js_invoke_function_" + fn] = js_invoke; }
+ const stream = fetch(uri);
+ const { instance: wasmInstance } = await WebAssembly.instantiateStreaming(stream, imports);
+ await finishInitializeWasm(wasmInstance);
+}"""
+
+ self.bindings_header += """
// WASM CODEC
-const nextMultipleOfFour = (value: number) => {
- return Math.ceil(value / 4) * 4;
+/* @internal */
+export function uint5ArrToBytes(inputArray: Array<UInt5>): Uint8Array {
+ const arr = new Uint8Array(inputArray.length);
+ for (var i = 0; i < inputArray.length; i++) {
+ arr[i] = inputArray[i].getVal();
+ }
+ return arr;
}
+/* @internal */
+export function WitnessVersionArrToBytes(inputArray: Array<WitnessVersion>): Uint8Array {
+ const arr = new Uint8Array(inputArray.length);
+ for (var i = 0; i < inputArray.length; i++) {
+ arr[i] = inputArray[i].getVal();
+ }
+ return arr;
+}
+
+
+
/* @internal */
export function encodeUint8Array (inputArray: Uint8Array): number {
- const cArrayPointer = wasm.TS_malloc(inputArray.length + 4);
- const arrayLengthView = new Uint32Array(wasm.memory.buffer, cArrayPointer, 1);
- arrayLengthView[0] = inputArray.length;
- const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 4, inputArray.length);
+ const cArrayPointer = wasm.TS_malloc(inputArray.length + 8);
+ const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
+ arrayLengthView[0] = BigInt(inputArray.length);
+ const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
arrayMemoryView.set(inputArray);
return cArrayPointer;
}
/* @internal */
export function encodeUint32Array (inputArray: Uint32Array|Array<number>): number {
- const cArrayPointer = wasm.TS_malloc((inputArray.length + 1) * 4);
- const arrayMemoryView = new Uint32Array(wasm.memory.buffer, cArrayPointer, inputArray.length);
- arrayMemoryView.set(inputArray, 1);
- arrayMemoryView[0] = inputArray.length;
+ const cArrayPointer = wasm.TS_malloc((inputArray.length + 2) * 4);
+ const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
+ arrayLengthView[0] = BigInt(inputArray.length);
+ const arrayMemoryView = new Uint32Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
+ arrayMemoryView.set(inputArray);
return cArrayPointer;
}
/* @internal */
export function encodeUint64Array (inputArray: BigUint64Array|Array<bigint>): number {
- const cArrayPointer = wasm.TS_malloc(inputArray.length * 8 + 1);
- const arrayLengthView = new Uint32Array(wasm.memory.buffer, cArrayPointer, 1);
- arrayLengthView[0] = inputArray.length;
- const arrayMemoryView = new BigUint64Array(wasm.memory.buffer, cArrayPointer + 4, inputArray.length);
- arrayMemoryView.set(inputArray);
+ const cArrayPointer = wasm.TS_malloc((inputArray.length + 1) * 8);
+ const arrayMemoryView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
+ arrayMemoryView.set(inputArray, 1);
+ arrayMemoryView[0] = BigInt(inputArray.length);
return cArrayPointer;
}
/* @internal */
export function check_arr_len(arr: Uint8Array, len: number): Uint8Array {
- if (arr.length != len) { throw new Error("Expected array of length " + len + "got " + arr.length); }
+ if (arr.length != len) { throw new Error("Expected array of length " + len + " got " + arr.length); }
return arr;
}
/* @internal */
export function getArrayLength(arrayPointer: number): number {
- const arraySizeViewer = new Uint32Array(wasm.memory.buffer, arrayPointer, 1);
- return arraySizeViewer[0];
+ const arraySizeViewer = new BigUint64Array(wasm.memory.buffer, arrayPointer, 1);
+ const len = arraySizeViewer[0];
+ if (len >= (2n ** 32n)) throw new Error("Bogus Array Size");
+ return Number(len % (2n ** 32n));
}
/* @internal */
export function decodeUint8Array (arrayPointer: number, free = true): Uint8Array {
const arraySize = getArrayLength(arrayPointer);
- const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 4, arraySize);
+ const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, arraySize);
// Clone the contents, TODO: In the future we should wrap the Viewer in a class that
// will free the underlying memory when it becomes unreachable instead of copying here.
// Note that doing so may have edge-case interactions with memory resizing (invalidating the buffer).
const arraySize = getArrayLength(arrayPointer);
const actualArrayViewer = new Uint32Array(
wasm.memory.buffer, // value
- arrayPointer + 4, // offset (ignoring length bytes)
+ arrayPointer + 8, // offset (ignoring length bytes)
arraySize // uint32 count
);
// Clone the contents, TODO: In the future we should wrap the Viewer in a class that
}
return actualArray;
}
+/* @internal */
+export function decodeUint64Array (arrayPointer: number, free = true): bigint[] {
+ const arraySize = getArrayLength(arrayPointer);
+ const actualArrayViewer = new BigUint64Array(
+ wasm.memory.buffer, // value
+ arrayPointer + 8, // offset (ignoring length bytes)
+ arraySize // uint32 count
+ );
+ // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
+ // will free the underlying memory when it becomes unreachable instead of copying here.
+ const actualArray = new Array(arraySize);
+ for (var i = 0; i < arraySize; i++) actualArray[i] = actualArrayViewer[i];
+ if (free) {
+ wasm.TS_free(arrayPointer);
+ }
+ return actualArray;
+}
+
+export function freeWasmMemory(pointer: number) { wasm.TS_free(pointer); }
+
+/* @internal */
+export function getU64ArrayElem(arrayPointer: number, idx: number): bigint {
+ const actualArrayViewer = new BigUint64Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
+ return actualArrayViewer[idx];
+}
/* @internal */
export function getU32ArrayElem(arrayPointer: number, idx: number): number {
- const actualArrayViewer = new Uint32Array(wasm.memory.buffer, arrayPointer + 4, idx + 1);
+ const actualArrayViewer = new Uint32Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
return actualArrayViewer[idx];
}
+/* @internal */
+export function getU8ArrayElem(arrayPointer: number, idx: number): number {
+ const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
+ return actualArrayViewer[idx];
+}
+
+
/* @internal */
export function encodeString(str: string): number {
const charArray = new TextEncoder().encode(str);
/* @internal */
export function decodeString(stringPointer: number, free = true): string {
const arraySize = getArrayLength(stringPointer);
- const memoryView = new Uint8Array(wasm.memory.buffer, stringPointer + 4, arraySize);
+ const memoryView = new Uint8Array(wasm.memory.buffer, stringPointer + 8, arraySize);
const result = new TextDecoder("utf-8").decode(memoryView);
if (free) {
self.bindings_header += "/* @internal */ export function debugPrintRemainingAllocs() { }\n"
with open(outdir + "/index.mts", 'a') as index:
- index.write("""import { initializeWasm as bindingsInit } from './bindings.mjs';
-export function initializeWasm(path: string) {
- bindingsInit(path);
+ index.write("""import { initializeWasmFetch, initializeWasmFromUint8Array } from './bindings.mjs';
+/** Initializes the WASM backend by calling `fetch()` on the given URI - Browser only */
+export async function initializeWasmWebFetch(uri: string) {
+ await initializeWasmFetch(uri);
+}
+/** Initializes the WASM backend given a Uint8Array of the .wasm binary file - Browser or Node.JS */
+export async function initializeWasmFromBinary(bin: Uint8Array) {
+ await initializeWasmFromUint8Array(bin);
}
+
""")
self.bindings_version_file = """export function get_ldk_java_bindings_version(): String {
self.common_base = """
function freer(f: () => void) { f() }
const finalizer = new FinalizationRegistry(freer);
-function get_freeer(ptr: number, free_fn: (ptr: number) => void) {
+function get_freeer(ptr: bigint, free_fn: (ptr: bigint) => void) {
return () => {
free_fn(ptr);
}
}
-export default class CommonBase {
- protected ptr: number;
+export class CommonBase {
+ protected ptr: bigint;
protected ptrs_to: object[] = [];
- protected constructor(ptr: number, free_fn: (ptr: number) => void) {
+ protected constructor(ptr: bigint, free_fn: (ptr: bigint) => void) {
this.ptr = ptr;
- if (Number.isFinite(ptr) && ptr != 0){
- finalizer.register(this, get_freeer(ptr, free_fn));
+ if (ptr != 0n){
+ finalizer.register(this, get_freeer(ptr, free_fn), this);
}
}
// In Java, protected means "any subclass can access fields on any other subclass'"
return o.ptr;
}
protected static set_null_skip_free(o: CommonBase) {
- o.ptr = 0;
- finalizer.unregister(o);
+ o.ptr = 0n;
+ // @ts-ignore TypeScript is wrong about the returnvalue of unregister here!
+ const did_unregister: boolean = finalizer.unregister(o);
+ if (!did_unregister)
+ throw new Error("FinalizationRegistry unregister should always unregister unless you double-free'd");
+ }
+}
+
+export class UInt5 {
+ public constructor(private val: number) {
+ if (val > 32 || val < 0) throw new Error("UInt5 value is out of range");
+ }
+ public getVal(): number {
+ return this.val;
}
}
+
+export class WitnessVersion {
+ public constructor(private val: number) {
+ if (val > 16 || val < 0) throw new Error("WitnessVersion value is out of range");
+ }
+ public getVal(): number {
+ return this.val;
+ }
+}
+
+export class UnqualifiedError {
+ public constructor(val: number) {}
+}
"""
self.txout_defn = """export class TxOut extends CommonBase {
public value: bigint;
/* @internal */
- public constructor(_dummy: object, ptr: number) {
+ public constructor(_dummy: object, ptr: bigint) {
super(ptr, bindings.TxOut_free);
this.script_pubkey = bindings.decodeUint8Array(bindings.TxOut_get_script_pubkey(ptr));
this.value = bindings.TxOut_get_value(ptr);
}
- public constructor_new(value: bigint, script_pubkey: Uint8Array): TxOut {
+ public static constructor_new(value: bigint, script_pubkey: Uint8Array): TxOut {
return new TxOut(null, bindings.TxOut_new(bindings.encodeUint8Array(script_pubkey), value));
}
}"""
static allocation* allocation_ll = NULL;
static allocation* freed_ll = NULL;
-void* __real_malloc(size_t len);
-void* __real_calloc(size_t nmemb, size_t len);
+extern void* __real_malloc(size_t len);
+extern void* __real_calloc(size_t nmemb, size_t len);
+extern void* __real_aligned_alloc(size_t alignment, size_t size);
static void new_allocation(void* res, const char* struct_name, int lineno) {
allocation* new_alloc = __real_malloc(sizeof(allocation));
new_alloc->ptr = res;
new_allocation(res, "calloc call", 0);
return res;
}
+void* __wrap_aligned_alloc(size_t alignment, size_t size) {
+ void* res = __real_aligned_alloc(alignment, size);
+ new_allocation(res, "aligned_alloc call", 0);
+ return res;
+}
void __wrap_free(void* ptr) {
if (ptr == NULL) return;
alloc_freed(ptr, 0);
#define DECL_ARR_TYPE(ty, name) \\
struct name##array { \\
- uint32_t arr_len; \\
+ uint64_t arr_len; /* uint32_t would suffice but we want to align uint64_ts as well */ \\
ty elems[]; \\
}; \\
typedef struct name##array * name##Array; \\
static inline name##Array init_##name##Array(size_t arr_len, int lineno) { \\
- name##Array arr = (name##Array)do_MALLOC(arr_len * sizeof(ty) + sizeof(uint32_t), #name" array init", lineno); \\
+ name##Array arr = (name##Array)do_MALLOC(arr_len * sizeof(ty) + sizeof(uint64_t), #name" array init", lineno); \\
arr->arr_len = arr_len; \\
return arr; \\
}
DECL_ARR_TYPE(int64_t, int64_t);
+DECL_ARR_TYPE(uint64_t, uint64_t);
DECL_ARR_TYPE(int8_t, int8_t);
DECL_ARR_TYPE(uint32_t, uint32_t);
DECL_ARR_TYPE(void*, ptr);
}"""
self.hu_struct_file_prefix = """
-import CommonBase from './CommonBase.mjs';
+import { CommonBase, UInt5, WitnessVersion, UnqualifiedError } from './CommonBase.mjs';
import * as bindings from '../bindings.mjs'
"""
self.util_fn_sfx = "}"
self.c_fn_ty_pfx = ""
self.file_ext = ".mts"
- self.ptr_c_ty = "uint32_t"
- self.ptr_native_ty = "number"
+ self.ptr_c_ty = "uint64_t"
+ self.ptr_native_ty = "bigint"
+ self.usize_c_ty = "uint32_t"
+ self.usize_native_ty = "number"
+ self.native_zero_ptr = "0n"
self.result_c_ty = "uint32_t"
self.ptr_arr = "ptrArray"
self.is_arr_some_check = ("", " != 0")
return None
def create_native_arr_call(self, arr_len, ty_info):
if ty_info.c_ty == "ptrArray":
- assert ty_info.subty is not None and ty_info.subty.c_ty.endswith("Array")
+ assert ty_info.rust_obj == "LDKCVec_u5Z" or (ty_info.subty is not None and ty_info.subty.c_ty.endswith("Array"))
return "init_" + ty_info.c_ty + "(" + arr_len + ", __LINE__)"
def set_native_arr_contents(self, arr_name, arr_len, ty_info):
if ty_info.c_ty == "int8_tArray":
def get_native_arr_contents(self, arr_name, dest_name, arr_len, ty_info, copy):
if ty_info.c_ty == "int8_tArray":
if copy:
- return "memcpy(" + dest_name + ", " + arr_name + "->elems, " + arr_len + ")"
+ return "memcpy(" + dest_name + ", " + arr_name + "->elems, " + arr_len + "); FREE(" + arr_name + ")"
+ assert not copy
if ty_info.c_ty == "ptrArray":
return "(void*) " + arr_name + "->elems"
else:
- assert not copy
return arr_name + "->elems"
def get_native_arr_elem(self, arr_name, idxc, ty_info):
assert False # Only called if above is None
def get_native_arr_ptr_call(self, ty_info):
if ty_info.subty is not None:
- return "(" + ty_info.subty.c_ty + "*)(((uint8_t*)", ") + 4)"
- return "(" + ty_info.c_ty + "*)(((uint8_t*)", ") + 4)"
+ return "(" + ty_info.subty.c_ty + "*)(((uint8_t*)", ") + 8)"
+ return "(" + ty_info.c_ty + "*)(((uint8_t*)", ") + 8)"
def get_native_arr_entry_call(self, ty_info, arr_name, idxc, entry_access):
return None
def cleanup_native_arr_ref_contents(self, arr_name, dest_name, arr_len, ty_info):
if ty_info.c_ty == "int8_tArray":
- return None
+ return "FREE(" + arr_name + ");"
else:
- return None
+ return "FREE(" + arr_name + ")"
def map_hu_array_elems(self, arr_name, conv_name, arr_ty, elem_ty):
- assert elem_ty.c_ty == "uint32_t" or elem_ty.c_ty.endswith("Array")
+ if elem_ty.rust_obj == "LDKu5":
+ return arr_name + " != null ? bindings.uint5ArrToBytes(" + arr_name + ") : null"
+ assert elem_ty.c_ty == "uint64_t" or elem_ty.c_ty.endswith("Array")
return arr_name + " != null ? " + arr_name + ".map(" + conv_name + " => " + elem_ty.from_hu_conv[0] + ") : null"
def str_ref_to_native_call(self, var_name, str_len):
def get_java_arr_len(self, arr_name):
return "bindings.getArrayLength(" + arr_name + ")"
def get_java_arr_elem(self, elem_ty, arr_name, idx):
- if elem_ty.c_ty == "uint32_t" or elem_ty.c_ty == "uintptr_t" or elem_ty.c_ty.endswith("Array"):
+ if elem_ty.c_ty.endswith("Array") or elem_ty.c_ty == "uintptr_t":
return "bindings.getU32ArrayElem(" + arr_name + ", " + idx + ")"
+ elif elem_ty.c_ty == "uint64_t":
+ return "bindings.getU64ArrayElem(" + arr_name + ", " + idx + ")"
+ elif elem_ty.rust_obj == "LDKu5":
+ return "bindings.getU8ArrayElem(" + arr_name + ", " + idx + ")"
else:
assert False
def constr_hu_array(self, ty_info, arr_len):
return "new Array(" + arr_len + ").fill(null)"
+ def cleanup_converted_native_array(self, ty_info, arr_name):
+ return "bindings.freeWasmMemory(" + arr_name + ")"
def primitive_arr_from_hu(self, mapped_ty, fixed_len, arr_name):
inner = arr_name
return ("bindings.encodeUint8Array(" + inner + ")", "")
elif mapped_ty.c_ty == "uint32_t":
return ("bindings.encodeUint32Array(" + inner + ")", "")
- elif mapped_ty.c_ty == "int64_t":
+ elif mapped_ty.c_ty == "int64_t" or mapped_ty.c_ty == "uint64_t":
return ("bindings.encodeUint64Array(" + inner + ")", "")
else:
print(mapped_ty.c_ty)
assert False
def primitive_arr_to_hu(self, mapped_ty, fixed_len, arr_name, conv_name):
- assert mapped_ty.c_ty == "uint8_t" or mapped_ty.c_ty == "int8_t"
- return "const " + conv_name + ": Uint8Array = bindings.decodeUint8Array(" + arr_name + ");"
+ if mapped_ty.c_ty == "uint8_t" or mapped_ty.c_ty == "int8_t":
+ return "const " + conv_name + ": Uint8Array = bindings.decodeUint8Array(" + arr_name + ");"
+ elif mapped_ty.c_ty == "uint64_t" or mapped_ty.c_ty == "int64_t":
+ return "const " + conv_name + ": bigint[] = bindings.decodeUint64Array(" + arr_name + ");"
+ else:
+ assert False
def var_decl_statement(self, ty_string, var_name, statement):
return "const " + var_name + ": " + ty_string + " = " + statement
with open(self.outdir + "/imports.mts.part", 'a') as imports:
imports.write(f"import {{ {', '.join(struct_names)} }} from '../{folder}/{struct_names[0]}.mjs';\n")
+ def fully_qualified_hu_ty_path(self, ty):
+ return ty.java_hu_ty
+
def native_c_unitary_enum_map(self, struct_name, variants, enum_doc_comment):
out_c = "static inline LDK" + struct_name + " LDK" + struct_name + "_from_js(int32_t ord) {\n"
out_c = out_c + "\tswitch (ord) {\n"
out_c = out_c + "\t}\n"
out_c = out_c + "}\n"
+ # Note that this is *not* marked /* @internal */ as we re-expose it directly in enums/
+ enum_comment_formatted = enum_doc_comment.replace("\n", "\n * ")
out_typescript = f"""
-/* @internal */
+/**
+ * {enum_comment_formatted}
+ */
export enum {struct_name} {{
{out_typescript_enum_fields}
}}
for fn_line in field_function_lines:
java_method_descriptor = ""
if fn_line.fn_name != "free" and fn_line.fn_name != "cloned":
+ out_java_interface += "\t/**" + fn_line.docs.replace("\n", "\n\t * ") + "\n\t */\n"
out_java_interface += "\t" + fn_line.fn_name + "("
out_interface_implementation_overrides += f"\t\t\t{fn_line.fn_name} ("
out_interface_implementation_overrides += "\t\t\t\treturn ret;\n"
out_interface_implementation_overrides += f"\t\t\t}},\n"
+ formatted_trait_docs = trait_doc_comment.replace("\n", "\n * ")
out_typescript_human = f"""
{self.hu_struct_file_prefix}
+/** An implementation of {struct_name.replace("LDK","")} */
export interface {struct_name.replace("LDK", "")}Interface {{
{out_java_interface}}}
held: {struct_name.replace("LDK", "")};
}}
+/**
+ * {formatted_trait_docs}
+ */
export class {struct_name.replace("LDK","")} extends CommonBase {{
/* @internal */
public bindings_instance?: bindings.{struct_name};
/* @internal */
- constructor(_dummy: object, ptr: number) {{
+ constructor(_dummy: object, ptr: bigint) {{
super(ptr, bindings.{struct_name.replace("LDK","")}_free);
this.bindings_instance = null;
}}
- static new_impl(arg: {struct_name.replace("LDK", "")}Interface{impl_constructor_arguments}): {struct_name.replace("LDK", "")} {{
+ /** Creates a new instance of {struct_name.replace("LDK","")} from a given implementation */
+ public static new_impl(arg: {struct_name.replace("LDK", "")}Interface{impl_constructor_arguments}): {struct_name.replace("LDK", "")} {{
const impl_holder: {struct_name}Holder = new {struct_name}Holder();
let structImplementation = {{
{out_interface_implementation_overrides} }} as bindings.{struct_name};
-{super_constructor_statements} const ptr: number = bindings.{struct_name}_new(structImplementation{bindings_instantiator});
+{super_constructor_statements} const ptr: bigint = bindings.{struct_name}_new(structImplementation{bindings_instantiator});
impl_holder.held = new {struct_name.replace("LDK", "")}(null, ptr);
impl_holder.held.bindings_instance = structImplementation;
{pointer_to_adder} return impl_holder.held;
}}
+
"""
self.obj_defined([struct_name.replace("LDK", ""), struct_name.replace("LDK", "") + "Interface"], "structs")
else:
out_typescript_bindings += f", {var[1]}: {var[0]}"
- out_typescript_bindings += f"""): number {{
+ out_typescript_bindings += f"""): bigint {{
if(!isWasmInitialized) {{
throw new Error("initializeWasm() must be awaited first!");
}}
out_c = out_c + arg_info.arg_name
out_c = out_c + arg_info.ret_conv[1].replace('\n', '\n\t') + "\n"
+ fn_suffix = ""
+ assert len(fn_line.args_ty) < 6
+ for arg_info in fn_line.args_ty:
+ if arg_info.c_ty == "uint64_t" or arg_info.c_ty == "int64_t":
+ fn_suffix += "b"
+ else:
+ fn_suffix += "u"
+ for i in range(0, 6 - len(fn_line.args_ty)):
+ fn_suffix += "u"
if fn_line.ret_ty_info.c_ty.endswith("Array"):
out_c += "\t" + fn_line.ret_ty_info.c_ty + " ret = (" + fn_line.ret_ty_info.c_ty + ")"
- out_c += "js_invoke_function_" + str(len(fn_line.args_ty)) + "(j_calls->instance_ptr, " + str(self.function_ptr_counter)
+ out_c += "js_invoke_function_" + fn_suffix + "(j_calls->instance_ptr, " + str(self.function_ptr_counter)
elif fn_line.ret_ty_info.java_ty == "void":
- out_c = out_c + "\tjs_invoke_function_" + str(len(fn_line.args_ty)) + "(j_calls->instance_ptr, " + str(self.function_ptr_counter)
+ out_c = out_c + "\tjs_invoke_function_" + fn_suffix + "(j_calls->instance_ptr, " + str(self.function_ptr_counter)
elif fn_line.ret_ty_info.java_hu_ty == "string":
- out_c = out_c + "\tjstring ret = (jstring)js_invoke_function_" + str(len(fn_line.args_ty)) + "(j_calls->instance_ptr, " + str(self.function_ptr_counter)
+ out_c += "\tjstring ret = (jstring)js_invoke_function_" + fn_suffix + "(j_calls->instance_ptr, " + str(self.function_ptr_counter)
elif not fn_line.ret_ty_info.passed_as_ptr:
- out_c = out_c + "\treturn js_invoke_function_" + str(len(fn_line.args_ty)) + "(j_calls->instance_ptr, " + str(self.function_ptr_counter)
+ out_c += "\treturn js_invoke_function_" + fn_suffix + "(j_calls->instance_ptr, " + str(self.function_ptr_counter)
else:
- out_c = out_c + "\tuint32_t ret = js_invoke_function_" + str(len(fn_line.args_ty)) + "(j_calls->instance_ptr, " + str(self.function_ptr_counter)
+ out_c += "\tuint32_t ret = js_invoke_function_" + fn_suffix + "(j_calls->instance_ptr, " + str(self.function_ptr_counter)
self.function_ptrs[self.function_ptr_counter] = (struct_name, fn_line.fn_name)
self.function_ptr_counter += 1
for idx, arg_info in enumerate(fn_line.args_ty):
if arg_info.ret_conv is not None:
- out_c = out_c + ", (uint32_t)" + arg_info.ret_conv_name
+ if arg_info.c_ty.endswith("Array"):
+ out_c += ", (uint32_t)" + arg_info.ret_conv_name
+ else:
+ out_c += ", " + arg_info.ret_conv_name
else:
- out_c = out_c + ", (uint32_t)" + arg_info.arg_name
+ assert False # TODO: Would we need some conversion here?
+ out_c += ", (uint32_t)" + arg_info.arg_name
+ for i in range(0, 6 - len(fn_line.args_ty)):
+ out_c += ", 0"
out_c = out_c + ");\n"
if fn_line.ret_ty_info.arg_conv is not None:
out_c = out_c + "\t" + fn_line.ret_ty_info.arg_conv.replace("\n", "\n\t") + "\n\treturn " + fn_line.ret_ty_info.arg_conv_name + ";\n"
out_c = out_c + "\treturn ret;\n"
out_c = out_c + "}\n"
- out_c = out_c + self.c_fn_ty_pfx + "long " + self.c_fn_name_define_pfx(struct_name + "_new", True) + "JSValue o"
+ out_c = out_c + self.c_fn_ty_pfx + "uint64_t " + self.c_fn_name_define_pfx(struct_name + "_new", True) + "JSValue o"
for var in flattened_field_var_conversions:
if isinstance(var, ConvInfo):
out_c = out_c + ", " + var.c_ty + " " + var.arg_name
else:
out_c = out_c + ", " + var[1]
out_c = out_c + ");\n"
- out_c = out_c + "\treturn (long)res_ptr;\n"
+ out_c = out_c + "\treturn tag_ptr(res_ptr, true);\n"
out_c = out_c + "}\n"
return (out_typescript_bindings, out_typescript_human, out_c)
def trait_struct_inc_refcnt(self, ty_info):
- return ""
+ base_conv = "\nif (" + ty_info.var_name + "_conv.free == " + ty_info.rust_obj + "_JCalls_free) {\n"
+ base_conv = base_conv + "\t// If this_arg is a JCalls struct, then we need to increment the refcnt in it.\n"
+ base_conv = base_conv + "\t" + ty_info.rust_obj + "_JCalls_cloned(&" + ty_info.var_name + "_conv);\n}"
+ return base_conv
def map_complex_enum(self, struct_name, variant_list, camel_to_snake, enum_doc_comment):
bindings_type = struct_name.replace("LDK", "")
out_java_enum += (self.hu_struct_file_prefix)
- java_hu_class = ""
+ java_hu_class = "/**\n * " + enum_doc_comment.replace("\n", "\n * ") + "\n */\n"
java_hu_class += "export class " + java_hu_type + " extends CommonBase {\n"
- java_hu_class += "\tprotected constructor(_dummy: object, ptr: number) { super(ptr, bindings." + bindings_type + "_free); }\n"
+ java_hu_class += "\tprotected constructor(_dummy: object, ptr: bigint) { super(ptr, bindings." + bindings_type + "_free); }\n"
java_hu_class += "\t/* @internal */\n"
- java_hu_class += f"\tpublic static constr_from_ptr(ptr: number): {java_hu_type} {{\n"
+ java_hu_class += f"\tpublic static constr_from_ptr(ptr: bigint): {java_hu_type} {{\n"
java_hu_class += f"\t\tconst raw_ty: number = bindings." + struct_name + "_ty_from_ptr(ptr);\n"
out_c += self.c_fn_ty_pfx + "uint32_t" + self.c_fn_name_define_pfx(struct_name + "_ty_from_ptr", True) + self.ptr_c_ty + " ptr) {\n"
- out_c += "\t" + struct_name + " *obj = (" + struct_name + "*)(ptr & ~1);\n"
+ out_c += "\t" + struct_name + " *obj = (" + struct_name + "*)untag_ptr(ptr);\n"
out_c += "\tswitch(obj->tag) {\n"
java_hu_class += "\t\tswitch (raw_ty) {\n"
java_hu_subclasses = ""
out_java += "\tprotected constructor() {}\n"
var_idx = 0
for var in variant_list:
- java_hu_subclasses = java_hu_subclasses + "export class " + java_hu_type + "_" + var.var_name + " extends " + java_hu_type + " {\n"
+ java_hu_subclasses += "/** A " + java_hu_type + " of type " + var.var_name + " */\n"
+ java_hu_subclasses += "export class " + java_hu_type + "_" + var.var_name + " extends " + java_hu_type + " {\n"
java_hu_class += f"\t\t\tcase {var_idx}: "
java_hu_class += "return new " + java_hu_type + "_" + var.var_name + "(ptr);\n"
out_c += f"\t\tcase {struct_name}_{var.var_name}: return {var_idx};\n"
hu_conv_body = ""
for idx, (field_ty, field_docs) in enumerate(var.fields):
- java_hu_subclasses = java_hu_subclasses + "\tpublic " + field_ty.arg_name + f": {field_ty.java_hu_ty};\n"
+ if field_docs is not None:
+ java_hu_subclasses += "\t/**\n\t * " + field_docs.replace("\n", "\n\t * ") + "\n\t */\n"
+ java_hu_subclasses += "\tpublic " + field_ty.arg_name + f": {field_ty.java_hu_ty};\n"
if field_ty.to_hu_conv is not None:
hu_conv_body += f"\t\tconst {field_ty.arg_name}: {field_ty.java_ty} = bindings.{struct_name}_{var.var_name}_get_{field_ty.arg_name}(ptr);\n"
hu_conv_body += f"\t\t" + field_ty.to_hu_conv.replace("\n", "\n\t\t\t") + "\n"
else:
hu_conv_body += f"\t\tthis.{field_ty.arg_name} = bindings.{struct_name}_{var.var_name}_get_{field_ty.arg_name}(ptr);\n"
java_hu_subclasses += "\t/* @internal */\n"
- java_hu_subclasses += "\tpublic constructor(ptr: number) {\n\t\tsuper(null, ptr);\n"
+ java_hu_subclasses += "\tpublic constructor(ptr: bigint) {\n\t\tsuper(null, ptr);\n"
java_hu_subclasses = java_hu_subclasses + hu_conv_body
java_hu_subclasses = java_hu_subclasses + "\t}\n}\n"
var_idx += 1
out_java += "}\n"
java_hu_class += "\t\t\tdefault:\n\t\t\t\tthrow new Error('oops, this should be unreachable'); // Unreachable without extending the (internal) bindings interface\n\t\t}\n\t}\n\n"
- out_java += self.fn_call_body(struct_name + "_ty_from_ptr", "uint32_t", "number", "ptr: number", "ptr")
+ out_java += self.fn_call_body(struct_name + "_ty_from_ptr", "uint32_t", "number", "ptr: bigint", "ptr")
out_c += ("\t\tdefault: abort();\n")
out_c += ("\t}\n}\n")
for idx, (field_map, _) in enumerate(var.fields):
fn_name = f"{struct_name}_{var.var_name}_get_{field_map.arg_name}"
out_c += self.c_fn_ty_pfx + field_map.c_ty + self.c_fn_name_define_pfx(fn_name, True) + self.ptr_c_ty + " ptr) {\n"
- out_c += "\t" + struct_name + " *obj = (" + struct_name + "*)(ptr & ~1);\n"
+ out_c += "\t" + struct_name + " *obj = (" + struct_name + "*)untag_ptr(ptr);\n"
out_c += f"\tassert(obj->tag == {struct_name}_{var.var_name});\n"
if field_map.ret_conv is not None:
out_c += ("\t\t\t" + field_map.ret_conv[0].replace("\n", "\n\t\t\t"))
else:
out_c += "\treturn " + "obj->" + camel_to_snake(var.var_name) + "." + field_map.arg_name + ";\n"
out_c += "}\n"
- out_java += self.fn_call_body(fn_name, field_map.c_ty, field_map.java_ty, "ptr: number", "ptr")
+ out_java += self.fn_call_body(fn_name, field_map.c_ty, field_map.java_ty, "ptr: bigint", "ptr")
out_java_enum += java_hu_class
self.struct_file_suffixes[java_hu_type] = java_hu_subclasses
self.obj_defined([java_hu_type], "structs")
hu_name = struct_name.replace("LDKC2Tuple", "TwoTuple").replace("LDKC3Tuple", "ThreeTuple").replace("LDK", "")
out_opaque_struct_human = f"{self.hu_struct_file_prefix}"
- if struct_name.startswith("LDKLocked"):
- out_opaque_struct_human += "/** XXX: DO NOT USE THIS - it remains locked until the GC runs (if that ever happens */"
+ constructor_body = "super(ptr, bindings." + struct_name.replace("LDK","") + "_free);"
+ extra_docs = ""
+ extra_body = ""
+ if struct_name.startswith("LDKLocked") or struct_name.startswith("LDKReadOnly"):
+ extra_docs = "\n * This type represents a lock and MUST BE MANUALLY FREE'd!"
+ constructor_body = 'super(ptr, () => { throw new Error("Locks must be manually freed with free()"); });'
+ extra_body = f"""
+ /** Releases this lock */
+ public free() {{
+ bindings.{struct_name.replace("LDK","")}_free(this.ptr);
+ CommonBase.set_null_skip_free(this);
+ }}"""
+ formatted_doc_comment = struct_doc_comment.replace("\n", "\n * ")
out_opaque_struct_human += f"""
+/**{extra_docs}
+ * {formatted_doc_comment}
+ */
export class {hu_name} extends CommonBase {implementations}{{
/* @internal */
- public constructor(_dummy: object, ptr: number) {{
- super(ptr, bindings.{struct_name.replace("LDK","")}_free);
- }}
+ public constructor(_dummy: object, ptr: bigint) {{
+ {constructor_body}
+ }}{extra_body}
"""
self.obj_defined([hu_name], "structs")
suffixes += "\tpublic res: " + res_map.java_hu_ty + ";\n"
suffixes += f"""
/* @internal */
- public constructor(_dummy: object, ptr: number) {{
+ public constructor(_dummy: object, ptr: bigint) {{
super(_dummy, ptr);
"""
if res_map.java_hu_ty == "void":
suffixes += "\tpublic err: " + err_map.java_hu_ty + ";\n"
suffixes += f"""
/* @internal */
- public constructor(_dummy: object, ptr: number) {{
+ public constructor(_dummy: object, ptr: bigint) {{
super(_dummy, ptr);
"""
if err_map.java_hu_ty == "void":
return f"""{self.hu_struct_file_prefix}
export class {human_ty} extends CommonBase {{
- protected constructor(_dummy: object, ptr: number) {{
+ protected constructor(_dummy: object, ptr: bigint) {{
super(ptr, bindings.{struct_name.replace("LDK","")}_free);
}}
/* @internal */
- public static constr_from_ptr(ptr: number): {human_ty} {{
+ public static constr_from_ptr(ptr: bigint): {human_ty} {{
if (bindings.{struct_name.replace("LDK", "")}_is_ok(ptr)) {{
return new {human_ty}_OK(null, ptr);
}} else {{
out_java = self.fn_call_body(method_name, return_type_info.c_ty, return_type_info.java_ty, method_argument_string, native_call_argument_string)
out_java_struct = ""
+ if doc_comment is not None:
+ out_java_struct = "\t/**\n\t * " + doc_comment.replace("\n", "\n\t * ") + "\n\t */\n"
+
if not args_known:
out_java_struct += ("\t// Skipped " + method_name + "\n")
else:
with open(self.outdir + "/bindings.mts", "a") as bindings:
bindings.write("""
-js_invoke = function(obj_ptr: number, fn_id: number, arg1: number, arg2: number, arg3: number, arg4: number, arg5: number, arg6: number, arg7: number, arg8: number, arg9: number, arg10: number) {
+js_invoke = function(obj_ptr: number, fn_id: number, arg1: bigint|number, arg2: bigint|number, arg3: bigint|number, arg4: bigint|number, arg5: bigint|number, arg6: bigint|number, arg7: bigint|number, arg8: bigint|number, arg9: bigint|number, arg10: bigint|number) {
const weak: WeakRef<object> = js_objs[obj_ptr];
if (weak == null || weak == undefined) {
console.error("Got function call on unknown/free'd JS object!");
console.error("Got function call on incorrect JS object!");
throw new Error("Got function call on incorrect JS object!");
}
- return fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+ const ret = fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+ if (ret === undefined || ret === null) return BigInt(0);
+ return BigInt(ret);
}""")
projects / ldk-java / blobdiff