X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=typescript_strings.py;h=adee0e31c78a64a880090f5fbd04c5c4b33abb50;hb=58bcafb0667cfd42ab085c62944b6a1bbd82e4e0;hp=892c63b802488a20b73b7101fa348e11b58afaee;hpb=1a849ce9a84a17a58ba0e19cb60dfdf95242356b;p=ldk-java diff --git a/typescript_strings.py b/typescript_strings.py index 892c63b8..adee0e31 100644 --- a/typescript_strings.py +++ b/typescript_strings.py @@ -17,10 +17,10 @@ class Consts: self.function_ptr_counter = 0 self.function_ptrs = {} self.c_type_map = dict( - uint8_t = ['number', 'Uint8Array'], - uint16_t = ['number', 'Uint16Array'], - uint32_t = ['number', 'Uint32Array'], - uint64_t = ['BigInt'], + uint8_t = ['number', 'number', 'Uint8Array'], + uint16_t = ['number', 'number', 'Uint16Array'], + uint32_t = ['number', 'number', 'Uint32Array'], + uint64_t = ['bigint', 'bigint', 'BigUint64Array'], ) self.java_type_map = dict( String = "number" @@ -29,14 +29,6 @@ class Consts: String = "string" ) - self.wasm_decoding_map = dict( - int8_tArray = 'decodeUint8Array' - ) - - self.wasm_encoding_map = dict( - int8_tArray = 'encodeUint8Array', - ) - self.to_hu_conv_templates = dict( ptr = 'const {var_name}_hu_conv: {human_type} = new {human_type}(null, {var_name});', default = 'const {var_name}_hu_conv: {human_type} = new {human_type}(null, {var_name});', @@ -44,7 +36,16 @@ class Consts: self.bindings_header = self.wasm_import_header(target) - self.bindings_version_file = "" + with open(outdir + "/index.mts", 'a') as index: + index.write("""import { initializeWasm as bindingsInit } from './bindings.mjs'; +export function initializeWasm(path: string) { + bindingsInit(path); +} +""") + + self.bindings_version_file = """export function get_ldk_java_bindings_version(): String { + return ""; +}""" self.bindings_footer = "" @@ -86,16 +87,16 @@ export default class CommonBase { /** The script_pubkey in this output */ public script_pubkey: Uint8Array; /** The value, in satoshis, of this output */ - public value: BigInt; + public value: bigint; /* @internal */ public constructor(_dummy: object, ptr: number) { super(ptr, bindings.TxOut_free); - this.script_pubkey = bindings.TxOut_get_script_pubkey(ptr); + 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 { - return new TxOut(null, bindings.TxOut_new(script_pubkey, value)); + public constructor_new(value: bigint, script_pubkey: Uint8Array): TxOut { + return new TxOut(null, bindings.TxOut_new(bindings.encodeUint8Array(script_pubkey), value)); } }""" self.obj_defined(["TxOut"], "structs") @@ -232,9 +233,14 @@ void __wrap_reallocarray(void* ptr, size_t new_sz) { DO_ASSERT(false); } -void __attribute__((destructor)) check_leaks() { +extern int snprintf(char *str, size_t size, const char *format, ...); +typedef int32_t ssize_t; +extern ssize_t write(int fd, const void *buf, size_t count); +void __attribute__((export_name("TS_check_leaks"))) check_leaks() { + char debug_str[1024]; for (allocation* a = allocation_ll; a != NULL; a = a->next) { - //XXX: fprintf(stderr, "%s %p remains\\n", a->struct_name, a->ptr); + int s_len = snprintf(debug_str, 1023, "%s %p remains\\n", a->struct_name, a->ptr); + write(2, debug_str, s_len); } DO_ASSERT(allocation_ll == NULL); } @@ -291,14 +297,27 @@ uint32_t __attribute__((export_name("TS_malloc"))) TS_malloc(uint32_t size) { void __attribute__((export_name("TS_free"))) TS_free(uint32_t ptr) { FREE((void*)ptr); } + +jstring __attribute__((export_name("TS_get_ldk_c_bindings_version"))) TS_get_ldk_c_bindings_version() { + const char *res = check_get_ldk_bindings_version(); + if (res == NULL) return NULL; + return str_ref_to_ts(res, strlen(res)); +} +jstring __attribute__((export_name("TS_get_ldk_version"))) get_ldk_version() { + const char *res = check_get_ldk_version(); + if (res == NULL) return NULL; + return str_ref_to_ts(res, strlen(res)); +} +#include "version.c" """ - self.c_version_file = "" + self.c_version_file = """jstring __attribute__((export_name("TS_get_lib_version_string"))) TS_get_lib_version_string() { + return str_ref_to_ts("", strlen("")); +}""" self.hu_struct_file_prefix = """ import CommonBase from './CommonBase.mjs'; import * as bindings from '../bindings.mjs' -import * as InternalUtils from '../InternalUtils.mjs' """ self.util_fn_pfx = self.hu_struct_file_prefix + "\nexport class UtilMethods extends CommonBase {\n" @@ -312,12 +331,6 @@ import * as InternalUtils from '../InternalUtils.mjs' self.is_arr_some_check = ("", " != 0") self.get_native_arr_len_call = ("", "->arr_len") - with open(outdir + "/InternalUtils.mts", "w") as f: - f.write("export function check_arr_len(arr: Uint8Array, len: number): Uint8Array {\n") - f.write("\tif (arr.length != len) { throw new Error(\"Expected array of length \" + len + \"got \" + arr.length); }\n") - f.write("\treturn arr;\n") - f.write("}") - def release_native_arr_ptr_call(self, ty_info, arr_var, arr_ptr_var): return None def create_native_arr_call(self, arr_len, ty_info): @@ -353,6 +366,7 @@ import * as InternalUtils from '../InternalUtils.mjs' return None 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") 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): @@ -369,6 +383,8 @@ import * as InternalUtils from '../InternalUtils.mjs' def wasm_import_header(self, target): res = """ +import * as version from './version.mjs'; + const imports: any = {}; imports.env = {}; @@ -386,6 +402,16 @@ imports.wasi_snapshot_preview1 = { } return 0; }, + "fd_close": (_fd: number) => { + // This is not generally called, but may be referenced in debug builds + console.log("wasi_snapshot_preview1:fd_close"); + return 58; // Not Supported + }, + "fd_seek": (_fd: number, _offset: bigint, _whence: number, _new_offset: number) => { + // This is not generally called, but may be referenced in debug builds + console.log("wasi_snapshot_preview1:fd_seek"); + return 58; // Not Supported + }, "random_get": (buf_ptr: number, buf_len: number) => { const buf = new Uint8Array(wasm.memory.buffer, buf_ptr, buf_len); crypto.getRandomValues(buf); @@ -423,34 +449,38 @@ let isWasmInitialized: boolean = false; if target == Target.NODEJS: res += """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); - wasm = wasmInstance.exports; - if (!wasm.test_bigint_pass_deadbeef0badf00d(BigInt("0xdeadbeef0badf00d"))) { - throw new Error(\"Currently need BigInt-as-u64 support, try ----experimental-wasm-bigint"); - } - isWasmInitialized = true; -}; -""" + const { instance: wasmInstance } = await WebAssembly.instantiate(source, imports);""" else: res += """ +/* @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); + const { instance: wasmInstance } = await WebAssembly.instantiateStreaming(stream, imports);""" + + return res + """ wasm = wasmInstance.exports; if (!wasm.test_bigint_pass_deadbeef0badf00d(BigInt("0xdeadbeef0badf00d"))) { throw new Error(\"Currently need BigInt-as-u64 support, try ----experimental-wasm-bigint"); } - isWasmInitialized = true; -}; - -""" - return res + """ + 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\"); + // Fetching the LDK versions from C also checks that the header and binaries match + if (wasm.TS_get_ldk_c_bindings_version() == 0) + throw new Error(\"LDK version did not match the header we built against\"); + if (wasm.TS_get_ldk_version() == 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()); + console.log(\"Loaded LDK-Java Bindings with LDK \" + ldk_version + \" and LDK-C-Bindings \" + c_bindings_version); + isWasmInitialized = true; +}; // WASM CODEC @@ -458,7 +488,8 @@ const nextMultipleOfFour = (value: number) => { return Math.ceil(value / 4) * 4; } -const encodeUint8Array = (inputArray: Uint8Array) => { +/* @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; @@ -466,32 +497,42 @@ const encodeUint8Array = (inputArray: Uint8Array) => { arrayMemoryView.set(inputArray); return cArrayPointer; } - -const encodeUint32Array = (inputArray: Uint32Array) => { +/* @internal */ +export function encodeUint32Array (inputArray: Uint32Array|Array): 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; return cArrayPointer; } +/* @internal */ +export function encodeUint64Array (inputArray: BigUint64Array|Array): 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); + return cArrayPointer; +} -const getArrayLength = (arrayPointer: number) => { - const arraySizeViewer = new Uint32Array( - wasm.memory.buffer, // value - arrayPointer, // offset - 1 // one int - ); +/* @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); } + return arr; +} + +/* @internal */ +export function getArrayLength(arrayPointer: number): number { + const arraySizeViewer = new Uint32Array(wasm.memory.buffer, arrayPointer, 1); return arraySizeViewer[0]; } -const decodeUint8Array = (arrayPointer: number, free = true) => { +/* @internal */ +export function decodeUint8Array (arrayPointer: number, free = true): Uint8Array { const arraySize = getArrayLength(arrayPointer); - const actualArrayViewer = new Uint8Array( - wasm.memory.buffer, // value - arrayPointer + 4, // offset (ignoring length bytes) - arraySize // uint8 count - ); + const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 4, 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 actualArray = actualArrayViewer.slice(0, arraySize); if (free) { wasm.TS_free(arrayPointer); @@ -514,11 +555,19 @@ const decodeUint32Array = (arrayPointer: number, free = true) => { return actualArray; } +/* @internal */ +export function getU32ArrayElem(arrayPointer: number, idx: number): number { + const actualArrayViewer = new Uint32Array(wasm.memory.buffer, arrayPointer + 4, idx + 1); + return actualArrayViewer[idx]; +} + +/* @internal */ export function encodeString(str: string): number { const charArray = new TextEncoder().encode(str); return encodeUint8Array(charArray); } +/* @internal */ export function decodeString(stringPointer: number, free = true): string { const arraySize = getArrayLength(stringPointer); const memoryView = new Uint8Array(wasm.memory.buffer, stringPointer + 4, arraySize); @@ -535,12 +584,43 @@ export function decodeString(stringPointer: number, free = true): string { def init_str(self): return "" + 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"): + return "bindings.getU32ArrayElem(" + arr_name + ", " + idx + ")" + else: + assert False def constr_hu_array(self, ty_info, arr_len): return "new Array(" + arr_len + ").fill(null)" + def primitive_arr_from_hu(self, mapped_ty, fixed_len, arr_name): + inner = arr_name + if fixed_len is not None: + assert mapped_ty.c_ty == "int8_t" + inner = "bindings.check_arr_len(" + arr_name + ", " + fixed_len + ")" + if mapped_ty.c_ty.endswith("Array"): + return ("bindings.encodeUint32Array(" + inner + ")", "") + elif mapped_ty.c_ty == "uint8_t" or mapped_ty.c_ty == "int8_t": + return ("bindings.encodeUint8Array(" + inner + ")", "") + elif mapped_ty.c_ty == "uint32_t": + return ("bindings.encodeUint32Array(" + inner + ")", "") + elif mapped_ty.c_ty == "int64_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 + ");" + def var_decl_statement(self, ty_string, var_name, statement): return "const " + var_name + ": " + ty_string + " = " + statement + def java_arr_ty_str(self, elem_ty_str): + return "number" + def for_n_in_range(self, n, minimum, maximum): return "for (var " + n + " = " + minimum + "; " + n + " < " + maximum + "; " + n + "++) {" def for_n_in_arr(self, n, arr_name, arr_elem_ty): @@ -571,8 +651,9 @@ export function decodeString(stringPointer: number, free = true): string { 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" + var_docs_repld = var_docs.replace("\n", "\n\t") + out_typescript_enum_fields += f"/**\n\t * {var_docs_repld}\n\t */\n" + out_typescript_enum_fields += f"\t{var},\n\t" out_c = out_c + "\t}\n" out_c = out_c + "\tabort();\n" out_c = out_c + "}\n" @@ -588,9 +669,10 @@ export function decodeString(stringPointer: number, free = true): string { out_c = out_c + "}\n" out_typescript = f""" - export enum {struct_name} {{ - {out_typescript_enum_fields} - }} +/* @internal */ +export enum {struct_name} {{ + {out_typescript_enum_fields} +}} """ out_typescript_enum = f"export {{ {struct_name} }} from \"../bindings.mjs\";" self.obj_defined([struct_name], "enums") @@ -602,8 +684,7 @@ export function decodeString(stringPointer: number, free = true): string { return (ty_info.rust_obj + "_from_js(", ")") def native_c_map_trait(self, struct_name, field_var_conversions, flattened_field_var_conversions, field_function_lines, trait_doc_comment): - out_typescript_bindings = "\n\n\n// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START\n\n" - + out_typescript_bindings = "" super_instantiator = "" bindings_instantiator = "" pointer_to_adder = "" @@ -726,7 +807,7 @@ export class {struct_name.replace("LDK","")} extends CommonBase {{ """ self.obj_defined([struct_name.replace("LDK", ""), struct_name.replace("LDK", "") + "Interface"], "structs") - out_typescript_bindings += "export interface " + struct_name + " {\n" + out_typescript_bindings += "/* @internal */\nexport interface " + struct_name + " {\n" java_meths = [] for fn_line in field_function_lines: if fn_line.fn_name != "free" and fn_line.fn_name != "cloned": @@ -741,7 +822,7 @@ export class {struct_name.replace("LDK","")} extends CommonBase {{ out_typescript_bindings += "}\n\n" - out_typescript_bindings += f"export function {struct_name}_new(impl: {struct_name}" + out_typescript_bindings += f"/* @internal */\nexport function {struct_name}_new(impl: {struct_name}" for var in flattened_field_var_conversions: if isinstance(var, ConvInfo): out_typescript_bindings += f", {var.arg_name}: {var.java_ty}" @@ -761,8 +842,6 @@ export class {struct_name.replace("LDK","")} extends CommonBase {{ }} """ - out_typescript_bindings += '\n// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END\n\n\n' - # Now that we've written out our java code (and created java_meths), generate C out_c = "typedef struct " + struct_name + "_JCalls {\n" out_c += "\tatomic_size_t refcnt;\n" @@ -937,7 +1016,7 @@ export class {struct_name.replace("LDK","")} extends CommonBase {{ java_hu_class += "\t\tswitch (raw_ty) {\n" java_hu_subclasses = "" - out_java += "export class " + struct_name + " {\n" + out_java += "/* @internal */\nexport class " + struct_name + " {\n" out_java += "\tprotected constructor() {}\n" var_idx = 0 for var in variant_list: @@ -1073,15 +1152,12 @@ export class {human_ty} extends CommonBase {{ def fn_call_body(self, method_name, return_c_ty, return_java_ty, method_argument_string, native_call_argument_string): has_return_value = return_c_ty != 'void' - needs_decoding = return_c_ty in self.wasm_decoding_map return_statement = 'return nativeResponseValue;' if not has_return_value: return_statement = '// debug statements here' - elif needs_decoding: - converter = self.wasm_decoding_map[return_c_ty] - return_statement = f"return {converter}(nativeResponseValue);" - return f"""export function {method_name}({method_argument_string}): {return_java_ty} {{ + return f"""/* @internal */ +export function {method_name}({method_argument_string}): {return_java_ty} {{ if(!isWasmInitialized) {{ throw new Error("initializeWasm() must be awaited first!"); }} @@ -1112,13 +1188,8 @@ export class {human_ty} extends CommonBase {{ out_c += (", ") if arg_conv_info.c_ty != "void": out_c += (arg_conv_info.c_ty + " " + arg_conv_info.arg_name) - needs_encoding = arg_conv_info.c_ty in self.wasm_encoding_map - native_argument = arg_conv_info.arg_name - if needs_encoding: - converter = self.wasm_encoding_map[arg_conv_info.c_ty] - native_argument = f"{converter}({arg_conv_info.arg_name})" method_argument_string += f"{arg_conv_info.arg_name}: {arg_conv_info.java_ty}" - native_call_argument_string += native_argument + native_call_argument_string += arg_conv_info.arg_name 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 = ""